from collections.abc import Mapping
from typing import List
from botocore.client import BaseClient


class ACM(BaseClient):
    class AddTagsToCertificateRequest(Mapping):
        pass

    class Tag(Mapping):
        pass

    class DeleteCertificateRequest(Mapping):
        pass

    class DescribeCertificateRequest(Mapping):
        pass

    class DescribeCertificateResponse(Mapping):
        pass

    class ExportCertificateRequest(Mapping):
        pass

    class ExportCertificateResponse(Mapping):
        pass

    class PassphraseBlob(object):
        pass

    class GetCertificateRequest(Mapping):
        pass

    class GetCertificateResponse(Mapping):
        pass

    class ImportCertificateRequest(Mapping):
        pass

    class ImportCertificateResponse(Mapping):
        pass

    class CertificateBodyBlob(object):
        pass

    class PrivateKeyBlob(object):
        pass

    class CertificateChainBlob(object):
        pass

    class ListCertificatesRequest(Mapping):
        pass

    class ListCertificatesResponse(Mapping):
        pass

    class CertificateStatus(object):
        pass

    class Filters(Mapping):
        pass

    class ListTagsForCertificateRequest(Mapping):
        pass

    class ListTagsForCertificateResponse(Mapping):
        pass

    class RemoveTagsFromCertificateRequest(Mapping):
        pass

    class RequestCertificateRequest(Mapping):
        pass

    class RequestCertificateResponse(Mapping):
        pass

    class DomainNameString(object):
        pass

    class DomainValidationOption(Mapping):
        pass

    class CertificateOptions(Mapping):
        pass

    class ResendValidationEmailRequest(Mapping):
        pass

    class UpdateCertificateOptionsRequest(Mapping):
        pass

    def add_tags_to_certificate(self, Tags: List[Tag], CertificateArn: str):
        pass

    def delete_certificate(self, CertificateArn: str):
        pass

    def describe_certificate(self, CertificateArn: str) -> DescribeCertificateResponse:
        pass

    def export_certificate(self, Passphrase: PassphraseBlob, CertificateArn: str) -> ExportCertificateResponse:
        pass

    def get_certificate(self, CertificateArn: str) -> GetCertificateResponse:
        pass

    def import_certificate(self, PrivateKey: PrivateKeyBlob, Certificate: CertificateBodyBlob, CertificateArn: str=None, CertificateChain: CertificateChainBlob=None) -> ImportCertificateResponse:
        pass

    def list_certificates(self, CertificateStatuses: List[CertificateStatus]=None, Includes: Filters=None, NextToken: str=None, MaxItems: int=None) -> ListCertificatesResponse:
        pass

    def list_tags_for_certificate(self, CertificateArn: str) -> ListTagsForCertificateResponse:
        pass

    def remove_tags_from_certificate(self, Tags: List[Tag], CertificateArn: str):
        pass

    def request_certificate(self, DomainName: str, ValidationMethod: str=None, SubjectAlternativeNames: List[DomainNameString]=None, IdempotencyToken: str=None, DomainValidationOptions: List[DomainValidationOption]=None, Options: CertificateOptions=None, CertificateAuthorityArn: str=None) -> RequestCertificateResponse:
        pass

    def resend_validation_email(self, ValidationDomain: str, Domain: str, CertificateArn: str):
        pass

    def update_certificate_options(self, Options: CertificateOptions, CertificateArn: str):
        pass


class ACMPCA(BaseClient):
    class CreateCertificateAuthorityRequest(Mapping):
        pass

    class CreateCertificateAuthorityResponse(Mapping):
        pass

    class CertificateAuthorityConfiguration(Mapping):
        pass

    class RevocationConfiguration(Mapping):
        pass

    class Tag(Mapping):
        pass

    class CreateCertificateAuthorityAuditReportRequest(Mapping):
        pass

    class CreateCertificateAuthorityAuditReportResponse(Mapping):
        pass

    class DeleteCertificateAuthorityRequest(Mapping):
        pass

    class DescribeCertificateAuthorityRequest(Mapping):
        pass

    class DescribeCertificateAuthorityResponse(Mapping):
        pass

    class DescribeCertificateAuthorityAuditReportRequest(Mapping):
        pass

    class DescribeCertificateAuthorityAuditReportResponse(Mapping):
        pass

    class GetCertificateRequest(Mapping):
        pass

    class GetCertificateResponse(Mapping):
        pass

    class GetCertificateAuthorityCertificateRequest(Mapping):
        pass

    class GetCertificateAuthorityCertificateResponse(Mapping):
        pass

    class GetCertificateAuthorityCsrRequest(Mapping):
        pass

    class GetCertificateAuthorityCsrResponse(Mapping):
        pass

    class ImportCertificateAuthorityCertificateRequest(Mapping):
        pass

    class CertificateBodyBlob(object):
        pass

    class CertificateChainBlob(object):
        pass

    class IssueCertificateRequest(Mapping):
        pass

    class IssueCertificateResponse(Mapping):
        pass

    class CsrBlob(object):
        pass

    class Validity(Mapping):
        pass

    class ListCertificateAuthoritiesRequest(Mapping):
        pass

    class ListCertificateAuthoritiesResponse(Mapping):
        pass

    class ListTagsRequest(Mapping):
        pass

    class ListTagsResponse(Mapping):
        pass

    class RestoreCertificateAuthorityRequest(Mapping):
        pass

    class RevokeCertificateRequest(Mapping):
        pass

    class TagCertificateAuthorityRequest(Mapping):
        pass

    class UntagCertificateAuthorityRequest(Mapping):
        pass

    class UpdateCertificateAuthorityRequest(Mapping):
        pass

    def create_certificate_authority(self, CertificateAuthorityType: str, CertificateAuthorityConfiguration: CertificateAuthorityConfiguration, RevocationConfiguration: RevocationConfiguration=None, IdempotencyToken: str=None, Tags: List[Tag]=None) -> CreateCertificateAuthorityResponse:
        pass

    def create_certificate_authority_audit_report(self, AuditReportResponseFormat: str, S3BucketName: str, CertificateAuthorityArn: str) -> CreateCertificateAuthorityAuditReportResponse:
        pass

    def delete_certificate_authority(self, CertificateAuthorityArn: str, PermanentDeletionTimeInDays: int=None):
        pass

    def describe_certificate_authority(self, CertificateAuthorityArn: str) -> DescribeCertificateAuthorityResponse:
        pass

    def describe_certificate_authority_audit_report(self, AuditReportId: str, CertificateAuthorityArn: str) -> DescribeCertificateAuthorityAuditReportResponse:
        pass

    def get_certificate(self, CertificateArn: str, CertificateAuthorityArn: str) -> GetCertificateResponse:
        pass

    def get_certificate_authority_certificate(self, CertificateAuthorityArn: str) -> GetCertificateAuthorityCertificateResponse:
        pass

    def get_certificate_authority_csr(self, CertificateAuthorityArn: str) -> GetCertificateAuthorityCsrResponse:
        pass

    def import_certificate_authority_certificate(self, CertificateChain: CertificateChainBlob, Certificate: CertificateBodyBlob, CertificateAuthorityArn: str):
        pass

    def issue_certificate(self, Validity: Validity, SigningAlgorithm: str, Csr: CsrBlob, CertificateAuthorityArn: str, IdempotencyToken: str=None) -> IssueCertificateResponse:
        pass

    def list_certificate_authorities(self, NextToken: str=None, MaxResults: int=None) -> ListCertificateAuthoritiesResponse:
        pass

    def list_tags(self, CertificateAuthorityArn: str, NextToken: str=None, MaxResults: int=None) -> ListTagsResponse:
        pass

    def restore_certificate_authority(self, CertificateAuthorityArn: str):
        pass

    def revoke_certificate(self, RevocationReason: str, CertificateSerial: str, CertificateAuthorityArn: str):
        pass

    def tag_certificate_authority(self, Tags: List[Tag], CertificateAuthorityArn: str):
        pass

    def untag_certificate_authority(self, Tags: List[Tag], CertificateAuthorityArn: str):
        pass

    def update_certificate_authority(self, CertificateAuthorityArn: str, RevocationConfiguration: RevocationConfiguration=None, Status: str=None):
        pass


class AlexaForBusiness(BaseClient):
    class ApproveSkillRequest(Mapping):
        pass

    class ApproveSkillResponse(Mapping):
        pass

    class AssociateContactWithAddressBookRequest(Mapping):
        pass

    class AssociateContactWithAddressBookResponse(Mapping):
        pass

    class AssociateDeviceWithRoomRequest(Mapping):
        pass

    class AssociateDeviceWithRoomResponse(Mapping):
        pass

    class AssociateSkillGroupWithRoomRequest(Mapping):
        pass

    class AssociateSkillGroupWithRoomResponse(Mapping):
        pass

    class AssociateSkillWithSkillGroupRequest(Mapping):
        pass

    class AssociateSkillWithSkillGroupResponse(Mapping):
        pass

    class AssociateSkillWithUsersRequest(Mapping):
        pass

    class AssociateSkillWithUsersResponse(Mapping):
        pass

    class CreateAddressBookRequest(Mapping):
        pass

    class CreateAddressBookResponse(Mapping):
        pass

    class CreateBusinessReportScheduleRequest(Mapping):
        pass

    class CreateBusinessReportScheduleResponse(Mapping):
        pass

    class BusinessReportContentRange(Mapping):
        pass

    class BusinessReportRecurrence(Mapping):
        pass

    class CreateConferenceProviderRequest(Mapping):
        pass

    class CreateConferenceProviderResponse(Mapping):
        pass

    class IPDialIn(Mapping):
        pass

    class PSTNDialIn(Mapping):
        pass

    class MeetingSetting(Mapping):
        pass

    class CreateContactRequest(Mapping):
        pass

    class CreateContactResponse(Mapping):
        pass

    class CreateProfileRequest(Mapping):
        pass

    class CreateProfileResponse(Mapping):
        pass

    class Boolean(object):
        pass

    class CreateRoomRequest(Mapping):
        pass

    class CreateRoomResponse(Mapping):
        pass

    class Tag(Mapping):
        pass

    class CreateSkillGroupRequest(Mapping):
        pass

    class CreateSkillGroupResponse(Mapping):
        pass

    class CreateUserRequest(Mapping):
        pass

    class CreateUserResponse(Mapping):
        pass

    class DeleteAddressBookRequest(Mapping):
        pass

    class DeleteAddressBookResponse(Mapping):
        pass

    class DeleteBusinessReportScheduleRequest(Mapping):
        pass

    class DeleteBusinessReportScheduleResponse(Mapping):
        pass

    class DeleteConferenceProviderRequest(Mapping):
        pass

    class DeleteConferenceProviderResponse(Mapping):
        pass

    class DeleteContactRequest(Mapping):
        pass

    class DeleteContactResponse(Mapping):
        pass

    class DeleteDeviceRequest(Mapping):
        pass

    class DeleteDeviceResponse(Mapping):
        pass

    class DeleteProfileRequest(Mapping):
        pass

    class DeleteProfileResponse(Mapping):
        pass

    class DeleteRoomRequest(Mapping):
        pass

    class DeleteRoomResponse(Mapping):
        pass

    class DeleteRoomSkillParameterRequest(Mapping):
        pass

    class DeleteRoomSkillParameterResponse(Mapping):
        pass

    class DeleteSkillAuthorizationRequest(Mapping):
        pass

    class DeleteSkillAuthorizationResponse(Mapping):
        pass

    class DeleteSkillGroupRequest(Mapping):
        pass

    class DeleteSkillGroupResponse(Mapping):
        pass

    class DeleteUserRequest(Mapping):
        pass

    class DeleteUserResponse(Mapping):
        pass

    class DisassociateContactFromAddressBookRequest(Mapping):
        pass

    class DisassociateContactFromAddressBookResponse(Mapping):
        pass

    class DisassociateDeviceFromRoomRequest(Mapping):
        pass

    class DisassociateDeviceFromRoomResponse(Mapping):
        pass

    class DisassociateSkillFromSkillGroupRequest(Mapping):
        pass

    class DisassociateSkillFromSkillGroupResponse(Mapping):
        pass

    class DisassociateSkillFromUsersRequest(Mapping):
        pass

    class DisassociateSkillFromUsersResponse(Mapping):
        pass

    class DisassociateSkillGroupFromRoomRequest(Mapping):
        pass

    class DisassociateSkillGroupFromRoomResponse(Mapping):
        pass

    class ForgetSmartHomeAppliancesRequest(Mapping):
        pass

    class ForgetSmartHomeAppliancesResponse(Mapping):
        pass

    class GetAddressBookRequest(Mapping):
        pass

    class GetAddressBookResponse(Mapping):
        pass

    class GetConferencePreferenceRequest(Mapping):
        pass

    class GetConferencePreferenceResponse(Mapping):
        pass

    class GetConferenceProviderRequest(Mapping):
        pass

    class GetConferenceProviderResponse(Mapping):
        pass

    class GetContactRequest(Mapping):
        pass

    class GetContactResponse(Mapping):
        pass

    class GetDeviceRequest(Mapping):
        pass

    class GetDeviceResponse(Mapping):
        pass

    class GetProfileRequest(Mapping):
        pass

    class GetProfileResponse(Mapping):
        pass

    class GetRoomRequest(Mapping):
        pass

    class GetRoomResponse(Mapping):
        pass

    class GetRoomSkillParameterRequest(Mapping):
        pass

    class GetRoomSkillParameterResponse(Mapping):
        pass

    class GetSkillGroupRequest(Mapping):
        pass

    class GetSkillGroupResponse(Mapping):
        pass

    class ListBusinessReportSchedulesRequest(Mapping):
        pass

    class ListBusinessReportSchedulesResponse(Mapping):
        pass

    class ListConferenceProvidersRequest(Mapping):
        pass

    class ListConferenceProvidersResponse(Mapping):
        pass

    class ListDeviceEventsRequest(Mapping):
        pass

    class ListDeviceEventsResponse(Mapping):
        pass

    class ListSkillsRequest(Mapping):
        pass

    class ListSkillsResponse(Mapping):
        pass

    class ListSkillsStoreCategoriesRequest(Mapping):
        pass

    class ListSkillsStoreCategoriesResponse(Mapping):
        pass

    class ListSkillsStoreSkillsByCategoryRequest(Mapping):
        pass

    class ListSkillsStoreSkillsByCategoryResponse(Mapping):
        pass

    class CategoryId(object):
        pass

    class ListSmartHomeAppliancesRequest(Mapping):
        pass

    class ListSmartHomeAppliancesResponse(Mapping):
        pass

    class ListTagsRequest(Mapping):
        pass

    class ListTagsResponse(Mapping):
        pass

    class PutConferencePreferenceRequest(Mapping):
        pass

    class PutConferencePreferenceResponse(Mapping):
        pass

    class ConferencePreference(Mapping):
        pass

    class PutRoomSkillParameterRequest(Mapping):
        pass

    class PutRoomSkillParameterResponse(Mapping):
        pass

    class RoomSkillParameter(Mapping):
        pass

    class PutSkillAuthorizationRequest(Mapping):
        pass

    class PutSkillAuthorizationResponse(Mapping):
        pass

    class AuthorizationResult(object):
        pass

    class RegisterAVSDeviceRequest(Mapping):
        pass

    class RegisterAVSDeviceResponse(Mapping):
        pass

    class RejectSkillRequest(Mapping):
        pass

    class RejectSkillResponse(Mapping):
        pass

    class ResolveRoomRequest(Mapping):
        pass

    class ResolveRoomResponse(Mapping):
        pass

    class RevokeInvitationRequest(Mapping):
        pass

    class RevokeInvitationResponse(Mapping):
        pass

    class SearchAddressBooksRequest(Mapping):
        pass

    class SearchAddressBooksResponse(Mapping):
        pass

    class Filter(Mapping):
        pass

    class Sort(Mapping):
        pass

    class SearchContactsRequest(Mapping):
        pass

    class SearchContactsResponse(Mapping):
        pass

    class SearchDevicesRequest(Mapping):
        pass

    class SearchDevicesResponse(Mapping):
        pass

    class SearchProfilesRequest(Mapping):
        pass

    class SearchProfilesResponse(Mapping):
        pass

    class SearchRoomsRequest(Mapping):
        pass

    class SearchRoomsResponse(Mapping):
        pass

    class SearchSkillGroupsRequest(Mapping):
        pass

    class SearchSkillGroupsResponse(Mapping):
        pass

    class SearchUsersRequest(Mapping):
        pass

    class SearchUsersResponse(Mapping):
        pass

    class SendInvitationRequest(Mapping):
        pass

    class SendInvitationResponse(Mapping):
        pass

    class StartDeviceSyncRequest(Mapping):
        pass

    class StartDeviceSyncResponse(Mapping):
        pass

    class Feature(object):
        pass

    class StartSmartHomeApplianceDiscoveryRequest(Mapping):
        pass

    class StartSmartHomeApplianceDiscoveryResponse(Mapping):
        pass

    class TagResourceRequest(Mapping):
        pass

    class TagResourceResponse(Mapping):
        pass

    class UntagResourceRequest(Mapping):
        pass

    class UntagResourceResponse(Mapping):
        pass

    class TagKey(object):
        pass

    class UpdateAddressBookRequest(Mapping):
        pass

    class UpdateAddressBookResponse(Mapping):
        pass

    class UpdateBusinessReportScheduleRequest(Mapping):
        pass

    class UpdateBusinessReportScheduleResponse(Mapping):
        pass

    class UpdateConferenceProviderRequest(Mapping):
        pass

    class UpdateConferenceProviderResponse(Mapping):
        pass

    class UpdateContactRequest(Mapping):
        pass

    class UpdateContactResponse(Mapping):
        pass

    class UpdateDeviceRequest(Mapping):
        pass

    class UpdateDeviceResponse(Mapping):
        pass

    class UpdateProfileRequest(Mapping):
        pass

    class UpdateProfileResponse(Mapping):
        pass

    class UpdateRoomRequest(Mapping):
        pass

    class UpdateRoomResponse(Mapping):
        pass

    class UpdateSkillGroupRequest(Mapping):
        pass

    class UpdateSkillGroupResponse(Mapping):
        pass

    def approve_skill(self, SkillId: str) -> ApproveSkillResponse:
        pass

    def associate_contact_with_address_book(self, AddressBookArn: str, ContactArn: str) -> AssociateContactWithAddressBookResponse:
        pass

    def associate_device_with_room(self, DeviceArn: str=None, RoomArn: str=None) -> AssociateDeviceWithRoomResponse:
        pass

    def associate_skill_group_with_room(self, SkillGroupArn: str=None, RoomArn: str=None) -> AssociateSkillGroupWithRoomResponse:
        pass

    def associate_skill_with_skill_group(self, SkillId: str, SkillGroupArn: str=None) -> AssociateSkillWithSkillGroupResponse:
        pass

    def associate_skill_with_users(self, SkillId: str, OrganizationArn: str=None) -> AssociateSkillWithUsersResponse:
        pass

    def create_address_book(self, Name: str, Description: str=None, ClientRequestToken: str=None) -> CreateAddressBookResponse:
        pass

    def create_business_report_schedule(self, ContentRange: BusinessReportContentRange, Format: str, ScheduleName: str=None, S3BucketName: str=None, S3KeyPrefix: str=None, Recurrence: BusinessReportRecurrence=None, ClientRequestToken: str=None) -> CreateBusinessReportScheduleResponse:
        pass

    def create_conference_provider(self, MeetingSetting: MeetingSetting, ConferenceProviderType: str, ConferenceProviderName: str, IPDialIn: IPDialIn=None, PSTNDialIn: PSTNDialIn=None, ClientRequestToken: str=None) -> CreateConferenceProviderResponse:
        pass

    def create_contact(self, FirstName: str, DisplayName: str=None, LastName: str=None, PhoneNumber: str=None, ClientRequestToken: str=None) -> CreateContactResponse:
        pass

    def create_profile(self, WakeWord: str, TemperatureUnit: str, DistanceUnit: str, Address: str, Timezone: str, ProfileName: str, ClientRequestToken: str=None, SetupModeDisabled: Boolean=None, MaxVolumeLimit: int=None, PSTNEnabled: Boolean=None) -> CreateProfileResponse:
        pass

    def create_room(self, RoomName: str, Description: str=None, ProfileArn: str=None, ProviderCalendarId: str=None, ClientRequestToken: str=None, Tags: List[Tag]=None) -> CreateRoomResponse:
        pass

    def create_skill_group(self, SkillGroupName: str, Description: str=None, ClientRequestToken: str=None) -> CreateSkillGroupResponse:
        pass

    def create_user(self, UserId: str, FirstName: str=None, LastName: str=None, Email: str=None, ClientRequestToken: str=None, Tags: List[Tag]=None) -> CreateUserResponse:
        pass

    def delete_address_book(self, AddressBookArn: str) -> DeleteAddressBookResponse:
        pass

    def delete_business_report_schedule(self, ScheduleArn: str) -> DeleteBusinessReportScheduleResponse:
        pass

    def delete_conference_provider(self, ConferenceProviderArn: str) -> DeleteConferenceProviderResponse:
        pass

    def delete_contact(self, ContactArn: str) -> DeleteContactResponse:
        pass

    def delete_device(self, DeviceArn: str) -> DeleteDeviceResponse:
        pass

    def delete_profile(self, ProfileArn: str=None) -> DeleteProfileResponse:
        pass

    def delete_room(self, RoomArn: str=None) -> DeleteRoomResponse:
        pass

    def delete_room_skill_parameter(self, ParameterKey: str, SkillId: str, RoomArn: str=None) -> DeleteRoomSkillParameterResponse:
        pass

    def delete_skill_authorization(self, SkillId: str, RoomArn: str=None) -> DeleteSkillAuthorizationResponse:
        pass

    def delete_skill_group(self, SkillGroupArn: str=None) -> DeleteSkillGroupResponse:
        pass

    def delete_user(self, EnrollmentId: str, UserArn: str=None) -> DeleteUserResponse:
        pass

    def disassociate_contact_from_address_book(self, AddressBookArn: str, ContactArn: str) -> DisassociateContactFromAddressBookResponse:
        pass

    def disassociate_device_from_room(self, DeviceArn: str=None) -> DisassociateDeviceFromRoomResponse:
        pass

    def disassociate_skill_from_skill_group(self, SkillId: str, SkillGroupArn: str=None) -> DisassociateSkillFromSkillGroupResponse:
        pass

    def disassociate_skill_from_users(self, SkillId: str, OrganizationArn: str=None) -> DisassociateSkillFromUsersResponse:
        pass

    def disassociate_skill_group_from_room(self, SkillGroupArn: str=None, RoomArn: str=None) -> DisassociateSkillGroupFromRoomResponse:
        pass

    def forget_smart_home_appliances(self, RoomArn: str) -> ForgetSmartHomeAppliancesResponse:
        pass

    def get_address_book(self, AddressBookArn: str) -> GetAddressBookResponse:
        pass

    def get_conference_preference(self) -> GetConferencePreferenceResponse:
        pass

    def get_conference_provider(self, ConferenceProviderArn: str) -> GetConferenceProviderResponse:
        pass

    def get_contact(self, ContactArn: str) -> GetContactResponse:
        pass

    def get_device(self, DeviceArn: str=None) -> GetDeviceResponse:
        pass

    def get_profile(self, ProfileArn: str=None) -> GetProfileResponse:
        pass

    def get_room(self, RoomArn: str=None) -> GetRoomResponse:
        pass

    def get_room_skill_parameter(self, ParameterKey: str, SkillId: str, RoomArn: str=None) -> GetRoomSkillParameterResponse:
        pass

    def get_skill_group(self, SkillGroupArn: str=None) -> GetSkillGroupResponse:
        pass

    def list_business_report_schedules(self, NextToken: str=None, MaxResults: int=None) -> ListBusinessReportSchedulesResponse:
        pass

    def list_conference_providers(self, NextToken: str=None, MaxResults: int=None) -> ListConferenceProvidersResponse:
        pass

    def list_device_events(self, DeviceArn: str, EventType: str=None, NextToken: str=None, MaxResults: int=None) -> ListDeviceEventsResponse:
        pass

    def list_skills(self, SkillGroupArn: str=None, EnablementType: str=None, SkillType: str=None, NextToken: str=None, MaxResults: int=None) -> ListSkillsResponse:
        pass

    def list_skills_store_categories(self, NextToken: str=None, MaxResults: int=None) -> ListSkillsStoreCategoriesResponse:
        pass

    def list_skills_store_skills_by_category(self, CategoryId: CategoryId, NextToken: str=None, MaxResults: int=None) -> ListSkillsStoreSkillsByCategoryResponse:
        pass

    def list_smart_home_appliances(self, RoomArn: str, MaxResults: int=None, NextToken: str=None) -> ListSmartHomeAppliancesResponse:
        pass

    def list_tags(self, Arn: str, NextToken: str=None, MaxResults: int=None) -> ListTagsResponse:
        pass

    def put_conference_preference(self, ConferencePreference: ConferencePreference) -> PutConferencePreferenceResponse:
        pass

    def put_room_skill_parameter(self, RoomSkillParameter: RoomSkillParameter, SkillId: str, RoomArn: str=None) -> PutRoomSkillParameterResponse:
        pass

    def put_skill_authorization(self, SkillId: str, AuthorizationResult: AuthorizationResult, RoomArn: str=None) -> PutSkillAuthorizationResponse:
        pass

    def register_avs_device(self, AmazonId: str, DeviceSerialNumber: str, ProductId: str, UserCode: str, ClientId: str) -> RegisterAVSDeviceResponse:
        pass

    def reject_skill(self, SkillId: str) -> RejectSkillResponse:
        pass

    def resolve_room(self, SkillId: str, UserId: str) -> ResolveRoomResponse:
        pass

    def revoke_invitation(self, UserArn: str=None, EnrollmentId: str=None) -> RevokeInvitationResponse:
        pass

    def search_address_books(self, Filters: List[Filter]=None, SortCriteria: List[Sort]=None, NextToken: str=None, MaxResults: int=None) -> SearchAddressBooksResponse:
        pass

    def search_contacts(self, Filters: List[Filter]=None, SortCriteria: List[Sort]=None, NextToken: str=None, MaxResults: int=None) -> SearchContactsResponse:
        pass

    def search_devices(self, NextToken: str=None, MaxResults: int=None, Filters: List[Filter]=None, SortCriteria: List[Sort]=None) -> SearchDevicesResponse:
        pass

    def search_profiles(self, NextToken: str=None, MaxResults: int=None, Filters: List[Filter]=None, SortCriteria: List[Sort]=None) -> SearchProfilesResponse:
        pass

    def search_rooms(self, NextToken: str=None, MaxResults: int=None, Filters: List[Filter]=None, SortCriteria: List[Sort]=None) -> SearchRoomsResponse:
        pass

    def search_skill_groups(self, NextToken: str=None, MaxResults: int=None, Filters: List[Filter]=None, SortCriteria: List[Sort]=None) -> SearchSkillGroupsResponse:
        pass

    def search_users(self, NextToken: str=None, MaxResults: int=None, Filters: List[Filter]=None, SortCriteria: List[Sort]=None) -> SearchUsersResponse:
        pass

    def send_invitation(self, UserArn: str=None) -> SendInvitationResponse:
        pass

    def start_device_sync(self, Features: List[Feature], RoomArn: str=None, DeviceArn: str=None) -> StartDeviceSyncResponse:
        pass

    def start_smart_home_appliance_discovery(self, RoomArn: str) -> StartSmartHomeApplianceDiscoveryResponse:
        pass

    def tag_resource(self, Tags: List[Tag], Arn: str) -> TagResourceResponse:
        pass

    def untag_resource(self, TagKeys: List[TagKey], Arn: str) -> UntagResourceResponse:
        pass

    def update_address_book(self, AddressBookArn: str, Name: str=None, Description: str=None) -> UpdateAddressBookResponse:
        pass

    def update_business_report_schedule(self, ScheduleArn: str, S3BucketName: str=None, S3KeyPrefix: str=None, Format: str=None, ScheduleName: str=None, Recurrence: BusinessReportRecurrence=None) -> UpdateBusinessReportScheduleResponse:
        pass

    def update_conference_provider(self, MeetingSetting: MeetingSetting, ConferenceProviderType: str, ConferenceProviderArn: str, IPDialIn: IPDialIn=None, PSTNDialIn: PSTNDialIn=None) -> UpdateConferenceProviderResponse:
        pass

    def update_contact(self, ContactArn: str, DisplayName: str=None, FirstName: str=None, LastName: str=None, PhoneNumber: str=None) -> UpdateContactResponse:
        pass

    def update_device(self, DeviceArn: str=None, DeviceName: str=None) -> UpdateDeviceResponse:
        pass

    def update_profile(self, ProfileArn: str=None, ProfileName: str=None, IsDefault: Boolean=None, Timezone: str=None, Address: str=None, DistanceUnit: str=None, TemperatureUnit: str=None, WakeWord: str=None, SetupModeDisabled: Boolean=None, MaxVolumeLimit: int=None, PSTNEnabled: Boolean=None) -> UpdateProfileResponse:
        pass

    def update_room(self, RoomArn: str=None, RoomName: str=None, Description: str=None, ProviderCalendarId: str=None, ProfileArn: str=None) -> UpdateRoomResponse:
        pass

    def update_skill_group(self, SkillGroupArn: str=None, SkillGroupName: str=None, Description: str=None) -> UpdateSkillGroupResponse:
        pass


class Amplify(BaseClient):
    class CreateAppRequest(Mapping):
        pass

    class CreateAppResult(Mapping):
        pass

    class EnvironmentVariables(object):
        pass

    class EnableBranchAutoBuild(object):
        pass

    class EnableBasicAuth(object):
        pass

    class CustomRule(Mapping):
        pass

    class Tags(object):
        pass

    class CreateBranchRequest(Mapping):
        pass

    class CreateBranchResult(Mapping):
        pass

    class EnableNotification(object):
        pass

    class EnableAutoBuild(object):
        pass

    class CreateDomainAssociationRequest(Mapping):
        pass

    class CreateDomainAssociationResult(Mapping):
        pass

    class EnableAutoSubDomain(object):
        pass

    class SubDomainSetting(Mapping):
        pass

    class DeleteAppRequest(Mapping):
        pass

    class DeleteAppResult(Mapping):
        pass

    class DeleteBranchRequest(Mapping):
        pass

    class DeleteBranchResult(Mapping):
        pass

    class DeleteDomainAssociationRequest(Mapping):
        pass

    class DeleteDomainAssociationResult(Mapping):
        pass

    class DeleteJobRequest(Mapping):
        pass

    class DeleteJobResult(Mapping):
        pass

    class GetAppRequest(Mapping):
        pass

    class GetAppResult(Mapping):
        pass

    class GetBranchRequest(Mapping):
        pass

    class GetBranchResult(Mapping):
        pass

    class GetDomainAssociationRequest(Mapping):
        pass

    class GetDomainAssociationResult(Mapping):
        pass

    class GetJobRequest(Mapping):
        pass

    class GetJobResult(Mapping):
        pass

    class ListAppsRequest(Mapping):
        pass

    class ListAppsResult(Mapping):
        pass

    class ListBranchesRequest(Mapping):
        pass

    class ListBranchesResult(Mapping):
        pass

    class ListDomainAssociationsRequest(Mapping):
        pass

    class ListDomainAssociationsResult(Mapping):
        pass

    class ListJobsRequest(Mapping):
        pass

    class ListJobsResult(Mapping):
        pass

    class StartJobRequest(Mapping):
        pass

    class StartJobResult(Mapping):
        pass

    class CommitTime(object):
        pass

    class StopJobRequest(Mapping):
        pass

    class StopJobResult(Mapping):
        pass

    class UpdateAppRequest(Mapping):
        pass

    class UpdateAppResult(Mapping):
        pass

    class UpdateBranchRequest(Mapping):
        pass

    class UpdateBranchResult(Mapping):
        pass

    class UpdateDomainAssociationRequest(Mapping):
        pass

    class UpdateDomainAssociationResult(Mapping):
        pass

    def create_app(self, oauthToken: str, platform: str, repository: str, name: str, description: str=None, iamServiceRoleArn: str=None, environmentVariables: EnvironmentVariables=None, enableBranchAutoBuild: EnableBranchAutoBuild=None, enableBasicAuth: EnableBasicAuth=None, basicAuthCredentials: str=None, customRules: List[CustomRule]=None, tags: Tags=None, buildSpec: str=None) -> CreateAppResult:
        pass

    def create_branch(self, branchName: str, appId: str, description: str=None, stage: str=None, framework: str=None, enableNotification: EnableNotification=None, enableAutoBuild: EnableAutoBuild=None, environmentVariables: EnvironmentVariables=None, basicAuthCredentials: str=None, enableBasicAuth: EnableBasicAuth=None, tags: Tags=None, buildSpec: str=None, ttl: str=None) -> CreateBranchResult:
        pass

    def create_domain_association(self, subDomainSettings: List[SubDomainSetting], domainName: str, appId: str, enableAutoSubDomain: EnableAutoSubDomain=None) -> CreateDomainAssociationResult:
        pass

    def delete_app(self, appId: str) -> DeleteAppResult:
        pass

    def delete_branch(self, branchName: str, appId: str) -> DeleteBranchResult:
        pass

    def delete_domain_association(self, domainName: str, appId: str) -> DeleteDomainAssociationResult:
        pass

    def delete_job(self, jobId: str, branchName: str, appId: str) -> DeleteJobResult:
        pass

    def get_app(self, appId: str) -> GetAppResult:
        pass

    def get_branch(self, branchName: str, appId: str) -> GetBranchResult:
        pass

    def get_domain_association(self, domainName: str, appId: str) -> GetDomainAssociationResult:
        pass

    def get_job(self, jobId: str, branchName: str, appId: str) -> GetJobResult:
        pass

    def list_apps(self, nextToken: str=None, maxResults: int=None) -> ListAppsResult:
        pass

    def list_branches(self, appId: str, nextToken: str=None, maxResults: int=None) -> ListBranchesResult:
        pass

    def list_domain_associations(self, appId: str, nextToken: str=None, maxResults: int=None) -> ListDomainAssociationsResult:
        pass

    def list_jobs(self, branchName: str, appId: str, nextToken: str=None, maxResults: int=None) -> ListJobsResult:
        pass

    def start_job(self, jobType: str, branchName: str, appId: str, jobId: str=None, jobReason: str=None, commitId: str=None, commitMessage: str=None, commitTime: CommitTime=None) -> StartJobResult:
        pass

    def stop_job(self, jobId: str, branchName: str, appId: str) -> StopJobResult:
        pass

    def update_app(self, appId: str, name: str=None, description: str=None, platform: str=None, iamServiceRoleArn: str=None, environmentVariables: EnvironmentVariables=None, enableBranchAutoBuild: EnableAutoBuild=None, enableBasicAuth: EnableBasicAuth=None, basicAuthCredentials: str=None, customRules: List[CustomRule]=None, buildSpec: str=None) -> UpdateAppResult:
        pass

    def update_branch(self, branchName: str, appId: str, description: str=None, framework: str=None, stage: str=None, enableNotification: EnableNotification=None, enableAutoBuild: EnableAutoBuild=None, environmentVariables: EnvironmentVariables=None, basicAuthCredentials: str=None, enableBasicAuth: EnableBasicAuth=None, buildSpec: str=None, ttl: str=None) -> UpdateBranchResult:
        pass

    def update_domain_association(self, subDomainSettings: List[SubDomainSetting], domainName: str, appId: str, enableAutoSubDomain: EnableAutoSubDomain=None) -> UpdateDomainAssociationResult:
        pass


class APIGateway(BaseClient):
    class CreateApiKeyRequest(Mapping):
        pass

    class ApiKey(Mapping):
        pass

    class Boolean(object):
        pass

    class StageKey(Mapping):
        pass

    class CreateAuthorizerRequest(Mapping):
        pass

    class Authorizer(Mapping):
        pass

    class ProviderARN(object):
        pass

    class CreateBasePathMappingRequest(Mapping):
        pass

    class BasePathMapping(Mapping):
        pass

    class CreateDeploymentRequest(Mapping):
        pass

    class Deployment(Mapping):
        pass

    class NullableBoolean(object):
        pass

    class MapOfStringToString(object):
        pass

    class DeploymentCanarySettings(Mapping):
        pass

    class CreateDocumentationPartRequest(Mapping):
        pass

    class DocumentationPart(Mapping):
        pass

    class DocumentationPartLocation(Mapping):
        pass

    class CreateDocumentationVersionRequest(Mapping):
        pass

    class DocumentationVersion(Mapping):
        pass

    class CreateDomainNameRequest(Mapping):
        pass

    class DomainName(Mapping):
        pass

    class EndpointConfiguration(Mapping):
        pass

    class CreateModelRequest(Mapping):
        pass

    class Model(Mapping):
        pass

    class CreateRequestValidatorRequest(Mapping):
        pass

    class RequestValidator(Mapping):
        pass

    class CreateResourceRequest(Mapping):
        pass

    class Resource(Mapping):
        pass

    class CreateRestApiRequest(Mapping):
        pass

    class RestApi(Mapping):
        pass

    class String(object):
        pass

    class CreateStageRequest(Mapping):
        pass

    class Stage(Mapping):
        pass

    class CanarySettings(Mapping):
        pass

    class CreateUsagePlanRequest(Mapping):
        pass

    class UsagePlan(Mapping):
        pass

    class ApiStage(Mapping):
        pass

    class ThrottleSettings(Mapping):
        pass

    class QuotaSettings(Mapping):
        pass

    class CreateUsagePlanKeyRequest(Mapping):
        pass

    class UsagePlanKey(Mapping):
        pass

    class CreateVpcLinkRequest(Mapping):
        pass

    class VpcLink(Mapping):
        pass

    class DeleteApiKeyRequest(Mapping):
        pass

    class DeleteAuthorizerRequest(Mapping):
        pass

    class DeleteBasePathMappingRequest(Mapping):
        pass

    class DeleteClientCertificateRequest(Mapping):
        pass

    class DeleteDeploymentRequest(Mapping):
        pass

    class DeleteDocumentationPartRequest(Mapping):
        pass

    class DeleteDocumentationVersionRequest(Mapping):
        pass

    class DeleteDomainNameRequest(Mapping):
        pass

    class DeleteGatewayResponseRequest(Mapping):
        pass

    class DeleteIntegrationRequest(Mapping):
        pass

    class DeleteIntegrationResponseRequest(Mapping):
        pass

    class DeleteMethodRequest(Mapping):
        pass

    class DeleteMethodResponseRequest(Mapping):
        pass

    class DeleteModelRequest(Mapping):
        pass

    class DeleteRequestValidatorRequest(Mapping):
        pass

    class DeleteResourceRequest(Mapping):
        pass

    class DeleteRestApiRequest(Mapping):
        pass

    class DeleteStageRequest(Mapping):
        pass

    class DeleteUsagePlanRequest(Mapping):
        pass

    class DeleteUsagePlanKeyRequest(Mapping):
        pass

    class DeleteVpcLinkRequest(Mapping):
        pass

    class FlushStageAuthorizersCacheRequest(Mapping):
        pass

    class FlushStageCacheRequest(Mapping):
        pass

    class GenerateClientCertificateRequest(Mapping):
        pass

    class ClientCertificate(Mapping):
        pass

    class GetAccountRequest(Mapping):
        pass

    class Account(Mapping):
        pass

    class GetApiKeyRequest(Mapping):
        pass

    class GetApiKeysRequest(Mapping):
        pass

    class ApiKeys(Mapping):
        pass

    class GetAuthorizerRequest(Mapping):
        pass

    class GetAuthorizersRequest(Mapping):
        pass

    class Authorizers(Mapping):
        pass

    class GetBasePathMappingRequest(Mapping):
        pass

    class GetBasePathMappingsRequest(Mapping):
        pass

    class BasePathMappings(Mapping):
        pass

    class GetClientCertificateRequest(Mapping):
        pass

    class GetClientCertificatesRequest(Mapping):
        pass

    class ClientCertificates(Mapping):
        pass

    class GetDeploymentRequest(Mapping):
        pass

    class GetDeploymentsRequest(Mapping):
        pass

    class Deployments(Mapping):
        pass

    class GetDocumentationPartRequest(Mapping):
        pass

    class GetDocumentationPartsRequest(Mapping):
        pass

    class DocumentationParts(Mapping):
        pass

    class GetDocumentationVersionRequest(Mapping):
        pass

    class GetDocumentationVersionsRequest(Mapping):
        pass

    class DocumentationVersions(Mapping):
        pass

    class GetDomainNameRequest(Mapping):
        pass

    class GetDomainNamesRequest(Mapping):
        pass

    class DomainNames(Mapping):
        pass

    class GetExportRequest(Mapping):
        pass

    class ExportResponse(Mapping):
        pass

    class GetGatewayResponseRequest(Mapping):
        pass

    class GatewayResponse(Mapping):
        pass

    class GetGatewayResponsesRequest(Mapping):
        pass

    class GatewayResponses(Mapping):
        pass

    class GetIntegrationRequest(Mapping):
        pass

    class Integration(Mapping):
        pass

    class GetIntegrationResponseRequest(Mapping):
        pass

    class IntegrationResponse(Mapping):
        pass

    class GetMethodRequest(Mapping):
        pass

    class Method(Mapping):
        pass

    class GetMethodResponseRequest(Mapping):
        pass

    class MethodResponse(Mapping):
        pass

    class GetModelRequest(Mapping):
        pass

    class GetModelTemplateRequest(Mapping):
        pass

    class Template(Mapping):
        pass

    class GetModelsRequest(Mapping):
        pass

    class Models(Mapping):
        pass

    class GetRequestValidatorRequest(Mapping):
        pass

    class GetRequestValidatorsRequest(Mapping):
        pass

    class RequestValidators(Mapping):
        pass

    class GetResourceRequest(Mapping):
        pass

    class GetResourcesRequest(Mapping):
        pass

    class Resources(Mapping):
        pass

    class GetRestApiRequest(Mapping):
        pass

    class GetRestApisRequest(Mapping):
        pass

    class RestApis(Mapping):
        pass

    class GetSdkRequest(Mapping):
        pass

    class SdkResponse(Mapping):
        pass

    class GetSdkTypeRequest(Mapping):
        pass

    class SdkType(Mapping):
        pass

    class GetSdkTypesRequest(Mapping):
        pass

    class SdkTypes(Mapping):
        pass

    class GetStageRequest(Mapping):
        pass

    class GetStagesRequest(Mapping):
        pass

    class Stages(Mapping):
        pass

    class GetTagsRequest(Mapping):
        pass

    class Tags(Mapping):
        pass

    class GetUsageRequest(Mapping):
        pass

    class Usage(Mapping):
        pass

    class GetUsagePlanRequest(Mapping):
        pass

    class GetUsagePlanKeyRequest(Mapping):
        pass

    class GetUsagePlanKeysRequest(Mapping):
        pass

    class UsagePlanKeys(Mapping):
        pass

    class GetUsagePlansRequest(Mapping):
        pass

    class UsagePlans(Mapping):
        pass

    class GetVpcLinkRequest(Mapping):
        pass

    class GetVpcLinksRequest(Mapping):
        pass

    class VpcLinks(Mapping):
        pass

    class ImportApiKeysRequest(Mapping):
        pass

    class ApiKeyIds(Mapping):
        pass

    class Blob(object):
        pass

    class ImportDocumentationPartsRequest(Mapping):
        pass

    class DocumentationPartIds(Mapping):
        pass

    class ImportRestApiRequest(Mapping):
        pass

    class PutGatewayResponseRequest(Mapping):
        pass

    class PutIntegrationRequest(Mapping):
        pass

    class PutIntegrationResponseRequest(Mapping):
        pass

    class PutMethodRequest(Mapping):
        pass

    class MapOfStringToBoolean(object):
        pass

    class PutMethodResponseRequest(Mapping):
        pass

    class PutRestApiRequest(Mapping):
        pass

    class TagResourceRequest(Mapping):
        pass

    class TestInvokeAuthorizerRequest(Mapping):
        pass

    class TestInvokeAuthorizerResponse(Mapping):
        pass

    class MapOfStringToList(object):
        pass

    class TestInvokeMethodRequest(Mapping):
        pass

    class TestInvokeMethodResponse(Mapping):
        pass

    class UntagResourceRequest(Mapping):
        pass

    class UpdateAccountRequest(Mapping):
        pass

    class PatchOperation(Mapping):
        pass

    class UpdateApiKeyRequest(Mapping):
        pass

    class UpdateAuthorizerRequest(Mapping):
        pass

    class UpdateBasePathMappingRequest(Mapping):
        pass

    class UpdateClientCertificateRequest(Mapping):
        pass

    class UpdateDeploymentRequest(Mapping):
        pass

    class UpdateDocumentationPartRequest(Mapping):
        pass

    class UpdateDocumentationVersionRequest(Mapping):
        pass

    class UpdateDomainNameRequest(Mapping):
        pass

    class UpdateGatewayResponseRequest(Mapping):
        pass

    class UpdateIntegrationRequest(Mapping):
        pass

    class UpdateIntegrationResponseRequest(Mapping):
        pass

    class UpdateMethodRequest(Mapping):
        pass

    class UpdateMethodResponseRequest(Mapping):
        pass

    class UpdateModelRequest(Mapping):
        pass

    class UpdateRequestValidatorRequest(Mapping):
        pass

    class UpdateResourceRequest(Mapping):
        pass

    class UpdateRestApiRequest(Mapping):
        pass

    class UpdateStageRequest(Mapping):
        pass

    class UpdateUsageRequest(Mapping):
        pass

    class UpdateUsagePlanRequest(Mapping):
        pass

    class UpdateVpcLinkRequest(Mapping):
        pass

    def create_api_key(self, name: str=None, description: str=None, enabled: Boolean=None, generateDistinctId: Boolean=None, value: str=None, stageKeys: List[StageKey]=None, customerId: str=None) -> ApiKey:
        pass

    def create_authorizer(self, type: str, name: str, restApiId: str, providerARNs: List[ProviderARN]=None, authType: str=None, authorizerUri: str=None, authorizerCredentials: str=None, identitySource: str=None, identityValidationExpression: str=None, authorizerResultTtlInSeconds: int=None) -> Authorizer:
        pass

    def create_base_path_mapping(self, restApiId: str, domainName: str, basePath: str=None, stage: str=None) -> BasePathMapping:
        pass

    def create_deployment(self, restApiId: str, stageName: str=None, stageDescription: str=None, description: str=None, cacheClusterEnabled: NullableBoolean=None, cacheClusterSize: str=None, variables: MapOfStringToString=None, canarySettings: DeploymentCanarySettings=None, tracingEnabled: NullableBoolean=None) -> Deployment:
        pass

    def create_documentation_part(self, properties: str, location: DocumentationPartLocation, restApiId: str) -> DocumentationPart:
        pass

    def create_documentation_version(self, documentationVersion: str, restApiId: str, stageName: str=None, description: str=None) -> DocumentationVersion:
        pass

    def create_domain_name(self, domainName: str, certificateName: str=None, certificateBody: str=None, certificatePrivateKey: str=None, certificateChain: str=None, certificateArn: str=None, regionalCertificateName: str=None, regionalCertificateArn: str=None, endpointConfiguration: EndpointConfiguration=None) -> DomainName:
        pass

    def create_model(self, contentType: str, name: str, restApiId: str, description: str=None, schema: str=None) -> Model:
        pass

    def create_request_validator(self, restApiId: str, name: str=None, validateRequestBody: Boolean=None, validateRequestParameters: Boolean=None) -> RequestValidator:
        pass

    def create_resource(self, pathPart: str, parentId: str, restApiId: str) -> Resource:
        pass

    def create_rest_api(self, name: str, description: str=None, version: str=None, cloneFrom: str=None, binaryMediaTypes: List[String]=None, minimumCompressionSize: int=None, apiKeySource: str=None, endpointConfiguration: EndpointConfiguration=None, policy: str=None) -> RestApi:
        pass

    def create_stage(self, deploymentId: str, stageName: str, restApiId: str, description: str=None, cacheClusterEnabled: Boolean=None, cacheClusterSize: str=None, variables: MapOfStringToString=None, documentationVersion: str=None, canarySettings: CanarySettings=None, tracingEnabled: Boolean=None, tags: MapOfStringToString=None) -> Stage:
        pass

    def create_usage_plan(self, name: str, description: str=None, apiStages: List[ApiStage]=None, throttle: ThrottleSettings=None, quota: QuotaSettings=None) -> UsagePlan:
        pass

    def create_usage_plan_key(self, keyType: str, keyId: str, usagePlanId: str) -> UsagePlanKey:
        pass

    def create_vpc_link(self, targetArns: List[String], name: str, description: str=None) -> VpcLink:
        pass

    def delete_api_key(self, apiKey: str):
        pass

    def delete_authorizer(self, authorizerId: str, restApiId: str):
        pass

    def delete_base_path_mapping(self, basePath: str, domainName: str):
        pass

    def delete_client_certificate(self, clientCertificateId: str):
        pass

    def delete_deployment(self, deploymentId: str, restApiId: str):
        pass

    def delete_documentation_part(self, documentationPartId: str, restApiId: str):
        pass

    def delete_documentation_version(self, documentationVersion: str, restApiId: str):
        pass

    def delete_domain_name(self, domainName: str):
        pass

    def delete_gateway_response(self, responseType: str, restApiId: str):
        pass

    def delete_integration(self, httpMethod: str, resourceId: str, restApiId: str):
        pass

    def delete_integration_response(self, statusCode: str, httpMethod: str, resourceId: str, restApiId: str):
        pass

    def delete_method(self, httpMethod: str, resourceId: str, restApiId: str):
        pass

    def delete_method_response(self, statusCode: str, httpMethod: str, resourceId: str, restApiId: str):
        pass

    def delete_model(self, modelName: str, restApiId: str):
        pass

    def delete_request_validator(self, requestValidatorId: str, restApiId: str):
        pass

    def delete_resource(self, resourceId: str, restApiId: str):
        pass

    def delete_rest_api(self, restApiId: str):
        pass

    def delete_stage(self, stageName: str, restApiId: str):
        pass

    def delete_usage_plan(self, usagePlanId: str):
        pass

    def delete_usage_plan_key(self, keyId: str, usagePlanId: str):
        pass

    def delete_vpc_link(self, vpcLinkId: str):
        pass

    def flush_stage_authorizers_cache(self, stageName: str, restApiId: str):
        pass

    def flush_stage_cache(self, stageName: str, restApiId: str):
        pass

    def generate_client_certificate(self, description: str=None) -> ClientCertificate:
        pass

    def get_account(self) -> Account:
        pass

    def get_api_key(self, apiKey: str, includeValue: NullableBoolean=None) -> ApiKey:
        pass

    def get_api_keys(self, position: str=None, limit: int=None, nameQuery: str=None, customerId: str=None, includeValues: NullableBoolean=None) -> ApiKeys:
        pass

    def get_authorizer(self, authorizerId: str, restApiId: str) -> Authorizer:
        pass

    def get_authorizers(self, restApiId: str, position: str=None, limit: int=None) -> Authorizers:
        pass

    def get_base_path_mapping(self, basePath: str, domainName: str) -> BasePathMapping:
        pass

    def get_base_path_mappings(self, domainName: str, position: str=None, limit: int=None) -> BasePathMappings:
        pass

    def get_client_certificate(self, clientCertificateId: str) -> ClientCertificate:
        pass

    def get_client_certificates(self, position: str=None, limit: int=None) -> ClientCertificates:
        pass

    def get_deployment(self, deploymentId: str, restApiId: str, embed: List[String]=None) -> Deployment:
        pass

    def get_deployments(self, restApiId: str, position: str=None, limit: int=None) -> Deployments:
        pass

    def get_documentation_part(self, documentationPartId: str, restApiId: str) -> DocumentationPart:
        pass

    def get_documentation_parts(self, restApiId: str, type: str=None, nameQuery: str=None, path: str=None, position: str=None, limit: int=None, locationStatus: str=None) -> DocumentationParts:
        pass

    def get_documentation_version(self, documentationVersion: str, restApiId: str) -> DocumentationVersion:
        pass

    def get_documentation_versions(self, restApiId: str, position: str=None, limit: int=None) -> DocumentationVersions:
        pass

    def get_domain_name(self, domainName: str) -> DomainName:
        pass

    def get_domain_names(self, position: str=None, limit: int=None) -> DomainNames:
        pass

    def get_export(self, exportType: str, stageName: str, restApiId: str, parameters: MapOfStringToString=None, accepts: str=None) -> ExportResponse:
        pass

    def get_gateway_response(self, responseType: str, restApiId: str) -> GatewayResponse:
        pass

    def get_gateway_responses(self, restApiId: str, position: str=None, limit: int=None) -> GatewayResponses:
        pass

    def get_integration(self, httpMethod: str, resourceId: str, restApiId: str) -> Integration:
        pass

    def get_integration_response(self, statusCode: str, httpMethod: str, resourceId: str, restApiId: str) -> IntegrationResponse:
        pass

    def get_method(self, httpMethod: str, resourceId: str, restApiId: str) -> Method:
        pass

    def get_method_response(self, statusCode: str, httpMethod: str, resourceId: str, restApiId: str) -> MethodResponse:
        pass

    def get_model(self, modelName: str, restApiId: str, flatten: Boolean=None) -> Model:
        pass

    def get_model_template(self, modelName: str, restApiId: str) -> Template:
        pass

    def get_models(self, restApiId: str, position: str=None, limit: int=None) -> Models:
        pass

    def get_request_validator(self, requestValidatorId: str, restApiId: str) -> RequestValidator:
        pass

    def get_request_validators(self, restApiId: str, position: str=None, limit: int=None) -> RequestValidators:
        pass

    def get_resource(self, resourceId: str, restApiId: str, embed: List[String]=None) -> Resource:
        pass

    def get_resources(self, restApiId: str, position: str=None, limit: int=None, embed: List[String]=None) -> Resources:
        pass

    def get_rest_api(self, restApiId: str) -> RestApi:
        pass

    def get_rest_apis(self, position: str=None, limit: int=None) -> RestApis:
        pass

    def get_sdk(self, sdkType: str, stageName: str, restApiId: str, parameters: MapOfStringToString=None) -> SdkResponse:
        pass

    def get_sdk_type(self, id: str) -> SdkType:
        pass

    def get_sdk_types(self, position: str=None, limit: int=None) -> SdkTypes:
        pass

    def get_stage(self, stageName: str, restApiId: str) -> Stage:
        pass

    def get_stages(self, restApiId: str, deploymentId: str=None) -> Stages:
        pass

    def get_tags(self, resourceArn: str, position: str=None, limit: int=None) -> Tags:
        pass

    def get_usage(self, endDate: str, startDate: str, usagePlanId: str, keyId: str=None, position: str=None, limit: int=None) -> Usage:
        pass

    def get_usage_plan(self, usagePlanId: str) -> UsagePlan:
        pass

    def get_usage_plan_key(self, keyId: str, usagePlanId: str) -> UsagePlanKey:
        pass

    def get_usage_plan_keys(self, usagePlanId: str, position: str=None, limit: int=None, nameQuery: str=None) -> UsagePlanKeys:
        pass

    def get_usage_plans(self, position: str=None, keyId: str=None, limit: int=None) -> UsagePlans:
        pass

    def get_vpc_link(self, vpcLinkId: str) -> VpcLink:
        pass

    def get_vpc_links(self, position: str=None, limit: int=None) -> VpcLinks:
        pass

    def import_api_keys(self, format: str, body: Blob, failOnWarnings: Boolean=None) -> ApiKeyIds:
        pass

    def import_documentation_parts(self, body: Blob, restApiId: str, mode: str=None, failOnWarnings: Boolean=None) -> DocumentationPartIds:
        pass

    def import_rest_api(self, body: Blob, failOnWarnings: Boolean=None, parameters: MapOfStringToString=None) -> RestApi:
        pass

    def put_gateway_response(self, responseType: str, restApiId: str, statusCode: str=None, responseParameters: MapOfStringToString=None, responseTemplates: MapOfStringToString=None) -> GatewayResponse:
        pass

    def put_integration(self, type: str, httpMethod: str, resourceId: str, restApiId: str, integrationHttpMethod: str=None, uri: str=None, connectionType: str=None, connectionId: str=None, credentials: str=None, requestParameters: MapOfStringToString=None, requestTemplates: MapOfStringToString=None, passthroughBehavior: str=None, cacheNamespace: str=None, cacheKeyParameters: List[String]=None, contentHandling: str=None, timeoutInMillis: int=None) -> Integration:
        pass

    def put_integration_response(self, statusCode: str, httpMethod: str, resourceId: str, restApiId: str, selectionPattern: str=None, responseParameters: MapOfStringToString=None, responseTemplates: MapOfStringToString=None, contentHandling: str=None) -> IntegrationResponse:
        pass

    def put_method(self, authorizationType: str, httpMethod: str, resourceId: str, restApiId: str, authorizerId: str=None, apiKeyRequired: Boolean=None, operationName: str=None, requestParameters: MapOfStringToBoolean=None, requestModels: MapOfStringToString=None, requestValidatorId: str=None, authorizationScopes: List[String]=None) -> Method:
        pass

    def put_method_response(self, statusCode: str, httpMethod: str, resourceId: str, restApiId: str, responseParameters: MapOfStringToBoolean=None, responseModels: MapOfStringToString=None) -> MethodResponse:
        pass

    def put_rest_api(self, body: Blob, restApiId: str, mode: str=None, failOnWarnings: Boolean=None, parameters: MapOfStringToString=None) -> RestApi:
        pass

    def tag_resource(self, tags: MapOfStringToString, resourceArn: str):
        pass

    def test_invoke_authorizer(self, authorizerId: str, restApiId: str, headers: MapOfStringToString=None, multiValueHeaders: MapOfStringToList=None, pathWithQueryString: str=None, body: str=None, stageVariables: MapOfStringToString=None, additionalContext: MapOfStringToString=None) -> TestInvokeAuthorizerResponse:
        pass

    def test_invoke_method(self, httpMethod: str, resourceId: str, restApiId: str, pathWithQueryString: str=None, body: str=None, headers: MapOfStringToString=None, multiValueHeaders: MapOfStringToList=None, clientCertificateId: str=None, stageVariables: MapOfStringToString=None) -> TestInvokeMethodResponse:
        pass

    def untag_resource(self, tagKeys: List[String], resourceArn: str):
        pass

    def update_account(self, patchOperations: List[PatchOperation]=None) -> Account:
        pass

    def update_api_key(self, apiKey: str, patchOperations: List[PatchOperation]=None) -> ApiKey:
        pass

    def update_authorizer(self, authorizerId: str, restApiId: str, patchOperations: List[PatchOperation]=None) -> Authorizer:
        pass

    def update_base_path_mapping(self, basePath: str, domainName: str, patchOperations: List[PatchOperation]=None) -> BasePathMapping:
        pass

    def update_client_certificate(self, clientCertificateId: str, patchOperations: List[PatchOperation]=None) -> ClientCertificate:
        pass

    def update_deployment(self, deploymentId: str, restApiId: str, patchOperations: List[PatchOperation]=None) -> Deployment:
        pass

    def update_documentation_part(self, documentationPartId: str, restApiId: str, patchOperations: List[PatchOperation]=None) -> DocumentationPart:
        pass

    def update_documentation_version(self, documentationVersion: str, restApiId: str, patchOperations: List[PatchOperation]=None) -> DocumentationVersion:
        pass

    def update_domain_name(self, domainName: str, patchOperations: List[PatchOperation]=None) -> DomainName:
        pass

    def update_gateway_response(self, responseType: str, restApiId: str, patchOperations: List[PatchOperation]=None) -> GatewayResponse:
        pass

    def update_integration(self, httpMethod: str, resourceId: str, restApiId: str, patchOperations: List[PatchOperation]=None) -> Integration:
        pass

    def update_integration_response(self, statusCode: str, httpMethod: str, resourceId: str, restApiId: str, patchOperations: List[PatchOperation]=None) -> IntegrationResponse:
        pass

    def update_method(self, httpMethod: str, resourceId: str, restApiId: str, patchOperations: List[PatchOperation]=None) -> Method:
        pass

    def update_method_response(self, statusCode: str, httpMethod: str, resourceId: str, restApiId: str, patchOperations: List[PatchOperation]=None) -> MethodResponse:
        pass

    def update_model(self, modelName: str, restApiId: str, patchOperations: List[PatchOperation]=None) -> Model:
        pass

    def update_request_validator(self, requestValidatorId: str, restApiId: str, patchOperations: List[PatchOperation]=None) -> RequestValidator:
        pass

    def update_resource(self, resourceId: str, restApiId: str, patchOperations: List[PatchOperation]=None) -> Resource:
        pass

    def update_rest_api(self, restApiId: str, patchOperations: List[PatchOperation]=None) -> RestApi:
        pass

    def update_stage(self, stageName: str, restApiId: str, patchOperations: List[PatchOperation]=None) -> Stage:
        pass

    def update_usage(self, keyId: str, usagePlanId: str, patchOperations: List[PatchOperation]=None) -> Usage:
        pass

    def update_usage_plan(self, usagePlanId: str, patchOperations: List[PatchOperation]=None) -> UsagePlan:
        pass

    def update_vpc_link(self, vpcLinkId: str, patchOperations: List[PatchOperation]=None) -> VpcLink:
        pass


class ApiGatewayManagementApi(BaseClient):
    class PostToConnectionRequest(Mapping):
        pass

    class Data(object):
        pass

    def post_to_connection(self, ConnectionId: str, Data: Data):
        pass


class ApiGatewayV2(BaseClient):
    class CreateApiRequest(Mapping):
        pass

    class CreateApiResponse(Mapping):
        pass

    class __boolean(object):
        pass

    class CreateApiMappingRequest(Mapping):
        pass

    class CreateApiMappingResponse(Mapping):
        pass

    class CreateAuthorizerRequest(Mapping):
        pass

    class CreateAuthorizerResponse(Mapping):
        pass

    class __string(object):
        pass

    class Arn(object):
        pass

    class CreateDeploymentRequest(Mapping):
        pass

    class CreateDeploymentResponse(Mapping):
        pass

    class CreateDomainNameRequest(Mapping):
        pass

    class CreateDomainNameResponse(Mapping):
        pass

    class DomainNameConfiguration(Mapping):
        pass

    class CreateIntegrationRequest(Mapping):
        pass

    class CreateIntegrationResult(Mapping):
        pass

    class IntegrationParameters(object):
        pass

    class TemplateMap(object):
        pass

    class CreateIntegrationResponseRequest(Mapping):
        pass

    class CreateIntegrationResponseResponse(Mapping):
        pass

    class CreateModelRequest(Mapping):
        pass

    class CreateModelResponse(Mapping):
        pass

    class CreateRouteRequest(Mapping):
        pass

    class CreateRouteResult(Mapping):
        pass

    class StringWithLengthBetween1And64(object):
        pass

    class RouteModels(object):
        pass

    class RouteParameters(object):
        pass

    class CreateRouteResponseRequest(Mapping):
        pass

    class CreateRouteResponseResponse(Mapping):
        pass

    class CreateStageRequest(Mapping):
        pass

    class CreateStageResponse(Mapping):
        pass

    class AccessLogSettings(Mapping):
        pass

    class RouteSettings(Mapping):
        pass

    class RouteSettingsMap(object):
        pass

    class StageVariablesMap(object):
        pass

    class DeleteApiRequest(Mapping):
        pass

    class DeleteApiMappingRequest(Mapping):
        pass

    class DeleteAuthorizerRequest(Mapping):
        pass

    class DeleteDeploymentRequest(Mapping):
        pass

    class DeleteDomainNameRequest(Mapping):
        pass

    class DeleteIntegrationRequest(Mapping):
        pass

    class DeleteIntegrationResponseRequest(Mapping):
        pass

    class DeleteModelRequest(Mapping):
        pass

    class DeleteRouteRequest(Mapping):
        pass

    class DeleteRouteResponseRequest(Mapping):
        pass

    class DeleteStageRequest(Mapping):
        pass

    class GetApiRequest(Mapping):
        pass

    class GetApiResponse(Mapping):
        pass

    class GetApiMappingRequest(Mapping):
        pass

    class GetApiMappingResponse(Mapping):
        pass

    class GetApiMappingsRequest(Mapping):
        pass

    class GetApiMappingsResponse(Mapping):
        pass

    class GetApisRequest(Mapping):
        pass

    class GetApisResponse(Mapping):
        pass

    class GetAuthorizerRequest(Mapping):
        pass

    class GetAuthorizerResponse(Mapping):
        pass

    class GetAuthorizersRequest(Mapping):
        pass

    class GetAuthorizersResponse(Mapping):
        pass

    class GetDeploymentRequest(Mapping):
        pass

    class GetDeploymentResponse(Mapping):
        pass

    class GetDeploymentsRequest(Mapping):
        pass

    class GetDeploymentsResponse(Mapping):
        pass

    class GetDomainNameRequest(Mapping):
        pass

    class GetDomainNameResponse(Mapping):
        pass

    class GetDomainNamesRequest(Mapping):
        pass

    class GetDomainNamesResponse(Mapping):
        pass

    class GetIntegrationRequest(Mapping):
        pass

    class GetIntegrationResult(Mapping):
        pass

    class GetIntegrationResponseRequest(Mapping):
        pass

    class GetIntegrationResponseResponse(Mapping):
        pass

    class GetIntegrationResponsesRequest(Mapping):
        pass

    class GetIntegrationResponsesResponse(Mapping):
        pass

    class GetIntegrationsRequest(Mapping):
        pass

    class GetIntegrationsResponse(Mapping):
        pass

    class GetModelRequest(Mapping):
        pass

    class GetModelResponse(Mapping):
        pass

    class GetModelTemplateRequest(Mapping):
        pass

    class GetModelTemplateResponse(Mapping):
        pass

    class GetModelsRequest(Mapping):
        pass

    class GetModelsResponse(Mapping):
        pass

    class GetRouteRequest(Mapping):
        pass

    class GetRouteResult(Mapping):
        pass

    class GetRouteResponseRequest(Mapping):
        pass

    class GetRouteResponseResponse(Mapping):
        pass

    class GetRouteResponsesRequest(Mapping):
        pass

    class GetRouteResponsesResponse(Mapping):
        pass

    class GetRoutesRequest(Mapping):
        pass

    class GetRoutesResponse(Mapping):
        pass

    class GetStageRequest(Mapping):
        pass

    class GetStageResponse(Mapping):
        pass

    class GetStagesRequest(Mapping):
        pass

    class GetStagesResponse(Mapping):
        pass

    class UpdateApiRequest(Mapping):
        pass

    class UpdateApiResponse(Mapping):
        pass

    class UpdateApiMappingRequest(Mapping):
        pass

    class UpdateApiMappingResponse(Mapping):
        pass

    class UpdateAuthorizerRequest(Mapping):
        pass

    class UpdateAuthorizerResponse(Mapping):
        pass

    class UpdateDeploymentRequest(Mapping):
        pass

    class UpdateDeploymentResponse(Mapping):
        pass

    class UpdateDomainNameRequest(Mapping):
        pass

    class UpdateDomainNameResponse(Mapping):
        pass

    class UpdateIntegrationRequest(Mapping):
        pass

    class UpdateIntegrationResult(Mapping):
        pass

    class UpdateIntegrationResponseRequest(Mapping):
        pass

    class UpdateIntegrationResponseResponse(Mapping):
        pass

    class UpdateModelRequest(Mapping):
        pass

    class UpdateModelResponse(Mapping):
        pass

    class UpdateRouteRequest(Mapping):
        pass

    class UpdateRouteResult(Mapping):
        pass

    class UpdateRouteResponseRequest(Mapping):
        pass

    class UpdateRouteResponseResponse(Mapping):
        pass

    class UpdateStageRequest(Mapping):
        pass

    class UpdateStageResponse(Mapping):
        pass

    def create_api(self, RouteSelectionExpression: str, ProtocolType: str, Name: str, ApiKeySelectionExpression: str=None, Description: str=None, DisableSchemaValidation: __boolean=None, Version: str=None) -> CreateApiResponse:
        pass

    def create_api_mapping(self, Stage: str, DomainName: str, ApiId: str, ApiMappingKey: str=None) -> CreateApiMappingResponse:
        pass

    def create_authorizer(self, Name: str, IdentitySource: List[__string], AuthorizerUri: str, AuthorizerType: str, ApiId: str, AuthorizerCredentialsArn: str=None, AuthorizerResultTtlInSeconds: int=None, IdentityValidationExpression: str=None, ProviderArns: List[Arn]=None) -> CreateAuthorizerResponse:
        pass

    def create_deployment(self, ApiId: str, Description: str=None, StageName: str=None) -> CreateDeploymentResponse:
        pass

    def create_domain_name(self, DomainName: str, DomainNameConfigurations: List[DomainNameConfiguration]=None) -> CreateDomainNameResponse:
        pass

    def create_integration(self, ApiId: str, ConnectionId: str=None, ConnectionType: str=None, ContentHandlingStrategy: str=None, CredentialsArn: str=None, Description: str=None, IntegrationMethod: str=None, IntegrationType: str=None, IntegrationUri: str=None, PassthroughBehavior: str=None, RequestParameters: IntegrationParameters=None, RequestTemplates: TemplateMap=None, TemplateSelectionExpression: str=None, TimeoutInMillis: int=None) -> CreateIntegrationResult:
        pass

    def create_integration_response(self, IntegrationResponseKey: str, IntegrationId: str, ApiId: str, ContentHandlingStrategy: str=None, ResponseParameters: IntegrationParameters=None, ResponseTemplates: TemplateMap=None, TemplateSelectionExpression: str=None) -> CreateIntegrationResponseResponse:
        pass

    def create_model(self, Name: str, ApiId: str, ContentType: str=None, Description: str=None, Schema: str=None) -> CreateModelResponse:
        pass

    def create_route(self, RouteKey: str, ApiId: str, ApiKeyRequired: __boolean=None, AuthorizationScopes: List[StringWithLengthBetween1And64]=None, AuthorizationType: str=None, AuthorizerId: str=None, ModelSelectionExpression: str=None, OperationName: str=None, RequestModels: RouteModels=None, RequestParameters: RouteParameters=None, RouteResponseSelectionExpression: str=None, Target: str=None) -> CreateRouteResult:
        pass

    def create_route_response(self, RouteResponseKey: str, RouteId: str, ApiId: str, ModelSelectionExpression: str=None, ResponseModels: RouteModels=None, ResponseParameters: RouteParameters=None) -> CreateRouteResponseResponse:
        pass

    def create_stage(self, StageName: str, ApiId: str, AccessLogSettings: AccessLogSettings=None, ClientCertificateId: str=None, DefaultRouteSettings: RouteSettings=None, DeploymentId: str=None, Description: str=None, RouteSettings: RouteSettingsMap=None, StageVariables: StageVariablesMap=None) -> CreateStageResponse:
        pass

    def delete_api(self, ApiId: str):
        pass

    def delete_api_mapping(self, DomainName: str, ApiMappingId: str, ApiId: str):
        pass

    def delete_authorizer(self, AuthorizerId: str, ApiId: str):
        pass

    def delete_deployment(self, DeploymentId: str, ApiId: str):
        pass

    def delete_domain_name(self, DomainName: str):
        pass

    def delete_integration(self, IntegrationId: str, ApiId: str):
        pass

    def delete_integration_response(self, IntegrationResponseId: str, IntegrationId: str, ApiId: str):
        pass

    def delete_model(self, ModelId: str, ApiId: str):
        pass

    def delete_route(self, RouteId: str, ApiId: str):
        pass

    def delete_route_response(self, RouteResponseId: str, RouteId: str, ApiId: str):
        pass

    def delete_stage(self, StageName: str, ApiId: str):
        pass

    def get_api(self, ApiId: str) -> GetApiResponse:
        pass

    def get_api_mapping(self, DomainName: str, ApiMappingId: str, ApiId: str) -> GetApiMappingResponse:
        pass

    def get_api_mappings(self, DomainName: str, MaxResults: str=None, NextToken: str=None) -> GetApiMappingsResponse:
        pass

    def get_apis(self, MaxResults: str=None, NextToken: str=None) -> GetApisResponse:
        pass

    def get_authorizer(self, AuthorizerId: str, ApiId: str) -> GetAuthorizerResponse:
        pass

    def get_authorizers(self, ApiId: str, MaxResults: str=None, NextToken: str=None) -> GetAuthorizersResponse:
        pass

    def get_deployment(self, DeploymentId: str, ApiId: str) -> GetDeploymentResponse:
        pass

    def get_deployments(self, ApiId: str, MaxResults: str=None, NextToken: str=None) -> GetDeploymentsResponse:
        pass

    def get_domain_name(self, DomainName: str) -> GetDomainNameResponse:
        pass

    def get_domain_names(self, MaxResults: str=None, NextToken: str=None) -> GetDomainNamesResponse:
        pass

    def get_integration(self, IntegrationId: str, ApiId: str) -> GetIntegrationResult:
        pass

    def get_integration_response(self, IntegrationResponseId: str, IntegrationId: str, ApiId: str) -> GetIntegrationResponseResponse:
        pass

    def get_integration_responses(self, IntegrationId: str, ApiId: str, MaxResults: str=None, NextToken: str=None) -> GetIntegrationResponsesResponse:
        pass

    def get_integrations(self, ApiId: str, MaxResults: str=None, NextToken: str=None) -> GetIntegrationsResponse:
        pass

    def get_model(self, ModelId: str, ApiId: str) -> GetModelResponse:
        pass

    def get_model_template(self, ModelId: str, ApiId: str) -> GetModelTemplateResponse:
        pass

    def get_models(self, ApiId: str, MaxResults: str=None, NextToken: str=None) -> GetModelsResponse:
        pass

    def get_route(self, RouteId: str, ApiId: str) -> GetRouteResult:
        pass

    def get_route_response(self, RouteResponseId: str, RouteId: str, ApiId: str) -> GetRouteResponseResponse:
        pass

    def get_route_responses(self, RouteId: str, ApiId: str, MaxResults: str=None, NextToken: str=None) -> GetRouteResponsesResponse:
        pass

    def get_routes(self, ApiId: str, MaxResults: str=None, NextToken: str=None) -> GetRoutesResponse:
        pass

    def get_stage(self, StageName: str, ApiId: str) -> GetStageResponse:
        pass

    def get_stages(self, ApiId: str, MaxResults: str=None, NextToken: str=None) -> GetStagesResponse:
        pass

    def update_api(self, ApiId: str, ApiKeySelectionExpression: str=None, Description: str=None, DisableSchemaValidation: __boolean=None, Name: str=None, RouteSelectionExpression: str=None, Version: str=None) -> UpdateApiResponse:
        pass

    def update_api_mapping(self, DomainName: str, ApiMappingId: str, ApiId: str, ApiMappingKey: str=None, Stage: str=None) -> UpdateApiMappingResponse:
        pass

    def update_authorizer(self, AuthorizerId: str, ApiId: str, AuthorizerCredentialsArn: str=None, AuthorizerResultTtlInSeconds: int=None, AuthorizerType: str=None, AuthorizerUri: str=None, IdentitySource: List[__string]=None, IdentityValidationExpression: str=None, Name: str=None, ProviderArns: List[Arn]=None) -> UpdateAuthorizerResponse:
        pass

    def update_deployment(self, DeploymentId: str, ApiId: str, Description: str=None) -> UpdateDeploymentResponse:
        pass

    def update_domain_name(self, DomainName: str, DomainNameConfigurations: List[DomainNameConfiguration]=None) -> UpdateDomainNameResponse:
        pass

    def update_integration(self, IntegrationId: str, ApiId: str, ConnectionId: str=None, ConnectionType: str=None, ContentHandlingStrategy: str=None, CredentialsArn: str=None, Description: str=None, IntegrationMethod: str=None, IntegrationType: str=None, IntegrationUri: str=None, PassthroughBehavior: str=None, RequestParameters: IntegrationParameters=None, RequestTemplates: TemplateMap=None, TemplateSelectionExpression: str=None, TimeoutInMillis: int=None) -> UpdateIntegrationResult:
        pass

    def update_integration_response(self, IntegrationResponseId: str, IntegrationId: str, ApiId: str, ContentHandlingStrategy: str=None, IntegrationResponseKey: str=None, ResponseParameters: IntegrationParameters=None, ResponseTemplates: TemplateMap=None, TemplateSelectionExpression: str=None) -> UpdateIntegrationResponseResponse:
        pass

    def update_model(self, ModelId: str, ApiId: str, ContentType: str=None, Description: str=None, Name: str=None, Schema: str=None) -> UpdateModelResponse:
        pass

    def update_route(self, RouteId: str, ApiId: str, ApiKeyRequired: __boolean=None, AuthorizationScopes: List[StringWithLengthBetween1And64]=None, AuthorizationType: str=None, AuthorizerId: str=None, ModelSelectionExpression: str=None, OperationName: str=None, RequestModels: RouteModels=None, RequestParameters: RouteParameters=None, RouteKey: str=None, RouteResponseSelectionExpression: str=None, Target: str=None) -> UpdateRouteResult:
        pass

    def update_route_response(self, RouteResponseId: str, RouteId: str, ApiId: str, ModelSelectionExpression: str=None, ResponseModels: RouteModels=None, ResponseParameters: RouteParameters=None, RouteResponseKey: str=None) -> UpdateRouteResponseResponse:
        pass

    def update_stage(self, StageName: str, ApiId: str, AccessLogSettings: AccessLogSettings=None, ClientCertificateId: str=None, DefaultRouteSettings: RouteSettings=None, DeploymentId: str=None, Description: str=None, RouteSettings: RouteSettingsMap=None, StageVariables: StageVariablesMap=None) -> UpdateStageResponse:
        pass


class ApplicationAutoScaling(BaseClient):
    class DeleteScalingPolicyRequest(Mapping):
        pass

    class DeleteScalingPolicyResponse(Mapping):
        pass

    class DeleteScheduledActionRequest(Mapping):
        pass

    class DeleteScheduledActionResponse(Mapping):
        pass

    class DeregisterScalableTargetRequest(Mapping):
        pass

    class DeregisterScalableTargetResponse(Mapping):
        pass

    class DescribeScalableTargetsRequest(Mapping):
        pass

    class DescribeScalableTargetsResponse(Mapping):
        pass

    class ResourceIdMaxLen1600(object):
        pass

    class DescribeScalingActivitiesRequest(Mapping):
        pass

    class DescribeScalingActivitiesResponse(Mapping):
        pass

    class DescribeScalingPoliciesRequest(Mapping):
        pass

    class DescribeScalingPoliciesResponse(Mapping):
        pass

    class DescribeScheduledActionsRequest(Mapping):
        pass

    class DescribeScheduledActionsResponse(Mapping):
        pass

    class PutScalingPolicyRequest(Mapping):
        pass

    class PutScalingPolicyResponse(Mapping):
        pass

    class StepScalingPolicyConfiguration(Mapping):
        pass

    class TargetTrackingScalingPolicyConfiguration(Mapping):
        pass

    class PutScheduledActionRequest(Mapping):
        pass

    class PutScheduledActionResponse(Mapping):
        pass

    class TimestampType(object):
        pass

    class ScalableTargetAction(Mapping):
        pass

    class RegisterScalableTargetRequest(Mapping):
        pass

    class RegisterScalableTargetResponse(Mapping):
        pass

    def delete_scaling_policy(self, ScalableDimension: str, ResourceId: str, ServiceNamespace: str, PolicyName: str) -> DeleteScalingPolicyResponse:
        pass

    def delete_scheduled_action(self, ResourceId: str, ScheduledActionName: str, ServiceNamespace: str, ScalableDimension: str=None) -> DeleteScheduledActionResponse:
        pass

    def deregister_scalable_target(self, ScalableDimension: str, ResourceId: str, ServiceNamespace: str) -> DeregisterScalableTargetResponse:
        pass

    def describe_scalable_targets(self, ServiceNamespace: str, ResourceIds: List[ResourceIdMaxLen1600]=None, ScalableDimension: str=None, MaxResults: int=None, NextToken: str=None) -> DescribeScalableTargetsResponse:
        pass

    def describe_scaling_activities(self, ServiceNamespace: str, ResourceId: str=None, ScalableDimension: str=None, MaxResults: int=None, NextToken: str=None) -> DescribeScalingActivitiesResponse:
        pass

    def describe_scaling_policies(self, ServiceNamespace: str, PolicyNames: List[ResourceIdMaxLen1600]=None, ResourceId: str=None, ScalableDimension: str=None, MaxResults: int=None, NextToken: str=None) -> DescribeScalingPoliciesResponse:
        pass

    def describe_scheduled_actions(self, ServiceNamespace: str, ScheduledActionNames: List[ResourceIdMaxLen1600]=None, ResourceId: str=None, ScalableDimension: str=None, MaxResults: int=None, NextToken: str=None) -> DescribeScheduledActionsResponse:
        pass

    def put_scaling_policy(self, ScalableDimension: str, ResourceId: str, ServiceNamespace: str, PolicyName: str, PolicyType: str=None, StepScalingPolicyConfiguration: StepScalingPolicyConfiguration=None, TargetTrackingScalingPolicyConfiguration: TargetTrackingScalingPolicyConfiguration=None) -> PutScalingPolicyResponse:
        pass

    def put_scheduled_action(self, ResourceId: str, ScheduledActionName: str, ServiceNamespace: str, Schedule: str=None, ScalableDimension: str=None, StartTime: TimestampType=None, EndTime: TimestampType=None, ScalableTargetAction: ScalableTargetAction=None) -> PutScheduledActionResponse:
        pass

    def register_scalable_target(self, ScalableDimension: str, ResourceId: str, ServiceNamespace: str, MinCapacity: int=None, MaxCapacity: int=None, RoleARN: str=None) -> RegisterScalableTargetResponse:
        pass


class AppMesh(BaseClient):
    class CreateMeshInput(Mapping):
        pass

    class CreateMeshOutput(Mapping):
        pass

    class CreateRouteInput(Mapping):
        pass

    class CreateRouteOutput(Mapping):
        pass

    class RouteSpec(Mapping):
        pass

    class CreateVirtualNodeInput(Mapping):
        pass

    class CreateVirtualNodeOutput(Mapping):
        pass

    class VirtualNodeSpec(Mapping):
        pass

    class CreateVirtualRouterInput(Mapping):
        pass

    class CreateVirtualRouterOutput(Mapping):
        pass

    class VirtualRouterSpec(Mapping):
        pass

    class DeleteMeshInput(Mapping):
        pass

    class DeleteMeshOutput(Mapping):
        pass

    class DeleteRouteInput(Mapping):
        pass

    class DeleteRouteOutput(Mapping):
        pass

    class DeleteVirtualNodeInput(Mapping):
        pass

    class DeleteVirtualNodeOutput(Mapping):
        pass

    class DeleteVirtualRouterInput(Mapping):
        pass

    class DeleteVirtualRouterOutput(Mapping):
        pass

    class DescribeMeshInput(Mapping):
        pass

    class DescribeMeshOutput(Mapping):
        pass

    class DescribeRouteInput(Mapping):
        pass

    class DescribeRouteOutput(Mapping):
        pass

    class DescribeVirtualNodeInput(Mapping):
        pass

    class DescribeVirtualNodeOutput(Mapping):
        pass

    class DescribeVirtualRouterInput(Mapping):
        pass

    class DescribeVirtualRouterOutput(Mapping):
        pass

    class ListMeshesInput(Mapping):
        pass

    class ListMeshesOutput(Mapping):
        pass

    class ListRoutesInput(Mapping):
        pass

    class ListRoutesOutput(Mapping):
        pass

    class ListVirtualNodesInput(Mapping):
        pass

    class ListVirtualNodesOutput(Mapping):
        pass

    class ListVirtualRoutersInput(Mapping):
        pass

    class ListVirtualRoutersOutput(Mapping):
        pass

    class UpdateRouteInput(Mapping):
        pass

    class UpdateRouteOutput(Mapping):
        pass

    class UpdateVirtualNodeInput(Mapping):
        pass

    class UpdateVirtualNodeOutput(Mapping):
        pass

    class UpdateVirtualRouterInput(Mapping):
        pass

    class UpdateVirtualRouterOutput(Mapping):
        pass

    def create_mesh(self, meshName: str, clientToken: str=None) -> CreateMeshOutput:
        pass

    def create_route(self, virtualRouterName: str, spec: RouteSpec, routeName: str, meshName: str, clientToken: str=None) -> CreateRouteOutput:
        pass

    def create_virtual_node(self, virtualNodeName: str, spec: VirtualNodeSpec, meshName: str, clientToken: str=None) -> CreateVirtualNodeOutput:
        pass

    def create_virtual_router(self, virtualRouterName: str, spec: VirtualRouterSpec, meshName: str, clientToken: str=None) -> CreateVirtualRouterOutput:
        pass

    def delete_mesh(self, meshName: str) -> DeleteMeshOutput:
        pass

    def delete_route(self, virtualRouterName: str, routeName: str, meshName: str) -> DeleteRouteOutput:
        pass

    def delete_virtual_node(self, virtualNodeName: str, meshName: str) -> DeleteVirtualNodeOutput:
        pass

    def delete_virtual_router(self, virtualRouterName: str, meshName: str) -> DeleteVirtualRouterOutput:
        pass

    def describe_mesh(self, meshName: str) -> DescribeMeshOutput:
        pass

    def describe_route(self, virtualRouterName: str, routeName: str, meshName: str) -> DescribeRouteOutput:
        pass

    def describe_virtual_node(self, virtualNodeName: str, meshName: str) -> DescribeVirtualNodeOutput:
        pass

    def describe_virtual_router(self, virtualRouterName: str, meshName: str) -> DescribeVirtualRouterOutput:
        pass

    def list_meshes(self, limit: int=None, nextToken: str=None) -> ListMeshesOutput:
        pass

    def list_routes(self, virtualRouterName: str, meshName: str, limit: int=None, nextToken: str=None) -> ListRoutesOutput:
        pass

    def list_virtual_nodes(self, meshName: str, limit: int=None, nextToken: str=None) -> ListVirtualNodesOutput:
        pass

    def list_virtual_routers(self, meshName: str, limit: int=None, nextToken: str=None) -> ListVirtualRoutersOutput:
        pass

    def update_route(self, virtualRouterName: str, spec: RouteSpec, routeName: str, meshName: str, clientToken: str=None) -> UpdateRouteOutput:
        pass

    def update_virtual_node(self, virtualNodeName: str, spec: VirtualNodeSpec, meshName: str, clientToken: str=None) -> UpdateVirtualNodeOutput:
        pass

    def update_virtual_router(self, virtualRouterName: str, spec: VirtualRouterSpec, meshName: str, clientToken: str=None) -> UpdateVirtualRouterOutput:
        pass


class AppStream(BaseClient):
    class AssociateFleetRequest(Mapping):
        pass

    class AssociateFleetResult(Mapping):
        pass

    class BatchAssociateUserStackRequest(Mapping):
        pass

    class BatchAssociateUserStackResult(Mapping):
        pass

    class UserStackAssociation(Mapping):
        pass

    class BatchDisassociateUserStackRequest(Mapping):
        pass

    class BatchDisassociateUserStackResult(Mapping):
        pass

    class CopyImageRequest(Mapping):
        pass

    class CopyImageResponse(Mapping):
        pass

    class CreateDirectoryConfigRequest(Mapping):
        pass

    class CreateDirectoryConfigResult(Mapping):
        pass

    class OrganizationalUnitDistinguishedName(object):
        pass

    class ServiceAccountCredentials(Mapping):
        pass

    class CreateFleetRequest(Mapping):
        pass

    class CreateFleetResult(Mapping):
        pass

    class ComputeCapacity(Mapping):
        pass

    class VpcConfig(Mapping):
        pass

    class BooleanObject(object):
        pass

    class DomainJoinInfo(Mapping):
        pass

    class Tags(object):
        pass

    class CreateImageBuilderRequest(Mapping):
        pass

    class CreateImageBuilderResult(Mapping):
        pass

    class CreateImageBuilderStreamingURLRequest(Mapping):
        pass

    class CreateImageBuilderStreamingURLResult(Mapping):
        pass

    class Long(object):
        pass

    class CreateStackRequest(Mapping):
        pass

    class CreateStackResult(Mapping):
        pass

    class StorageConnector(Mapping):
        pass

    class UserSetting(Mapping):
        pass

    class ApplicationSettings(Mapping):
        pass

    class CreateStreamingURLRequest(Mapping):
        pass

    class CreateStreamingURLResult(Mapping):
        pass

    class CreateUserRequest(Mapping):
        pass

    class CreateUserResult(Mapping):
        pass

    class DeleteDirectoryConfigRequest(Mapping):
        pass

    class DeleteDirectoryConfigResult(Mapping):
        pass

    class DeleteFleetRequest(Mapping):
        pass

    class DeleteFleetResult(Mapping):
        pass

    class DeleteImageRequest(Mapping):
        pass

    class DeleteImageResult(Mapping):
        pass

    class DeleteImageBuilderRequest(Mapping):
        pass

    class DeleteImageBuilderResult(Mapping):
        pass

    class DeleteImagePermissionsRequest(Mapping):
        pass

    class DeleteImagePermissionsResult(Mapping):
        pass

    class DeleteStackRequest(Mapping):
        pass

    class DeleteStackResult(Mapping):
        pass

    class DeleteUserRequest(Mapping):
        pass

    class DeleteUserResult(Mapping):
        pass

    class DescribeDirectoryConfigsRequest(Mapping):
        pass

    class DescribeDirectoryConfigsResult(Mapping):
        pass

    class DirectoryName(object):
        pass

    class DescribeFleetsRequest(Mapping):
        pass

    class DescribeFleetsResult(Mapping):
        pass

    class String(object):
        pass

    class DescribeImageBuildersRequest(Mapping):
        pass

    class DescribeImageBuildersResult(Mapping):
        pass

    class DescribeImagePermissionsRequest(Mapping):
        pass

    class DescribeImagePermissionsResult(Mapping):
        pass

    class AwsAccountId(object):
        pass

    class DescribeImagesRequest(Mapping):
        pass

    class DescribeImagesResult(Mapping):
        pass

    class Arn(object):
        pass

    class DescribeSessionsRequest(Mapping):
        pass

    class DescribeSessionsResult(Mapping):
        pass

    class DescribeStacksRequest(Mapping):
        pass

    class DescribeStacksResult(Mapping):
        pass

    class DescribeUserStackAssociationsRequest(Mapping):
        pass

    class DescribeUserStackAssociationsResult(Mapping):
        pass

    class DescribeUsersRequest(Mapping):
        pass

    class DescribeUsersResult(Mapping):
        pass

    class DisableUserRequest(Mapping):
        pass

    class DisableUserResult(Mapping):
        pass

    class DisassociateFleetRequest(Mapping):
        pass

    class DisassociateFleetResult(Mapping):
        pass

    class EnableUserRequest(Mapping):
        pass

    class EnableUserResult(Mapping):
        pass

    class ExpireSessionRequest(Mapping):
        pass

    class ExpireSessionResult(Mapping):
        pass

    class ListAssociatedFleetsRequest(Mapping):
        pass

    class ListAssociatedFleetsResult(Mapping):
        pass

    class ListAssociatedStacksRequest(Mapping):
        pass

    class ListAssociatedStacksResult(Mapping):
        pass

    class ListTagsForResourceRequest(Mapping):
        pass

    class ListTagsForResourceResponse(Mapping):
        pass

    class StartFleetRequest(Mapping):
        pass

    class StartFleetResult(Mapping):
        pass

    class StartImageBuilderRequest(Mapping):
        pass

    class StartImageBuilderResult(Mapping):
        pass

    class StopFleetRequest(Mapping):
        pass

    class StopFleetResult(Mapping):
        pass

    class StopImageBuilderRequest(Mapping):
        pass

    class StopImageBuilderResult(Mapping):
        pass

    class TagResourceRequest(Mapping):
        pass

    class TagResourceResponse(Mapping):
        pass

    class UntagResourceRequest(Mapping):
        pass

    class UntagResourceResponse(Mapping):
        pass

    class TagKey(object):
        pass

    class UpdateDirectoryConfigRequest(Mapping):
        pass

    class UpdateDirectoryConfigResult(Mapping):
        pass

    class UpdateFleetRequest(Mapping):
        pass

    class UpdateFleetResult(Mapping):
        pass

    class Boolean(object):
        pass

    class FleetAttribute(object):
        pass

    class UpdateImagePermissionsRequest(Mapping):
        pass

    class UpdateImagePermissionsResult(Mapping):
        pass

    class ImagePermissions(Mapping):
        pass

    class UpdateStackRequest(Mapping):
        pass

    class UpdateStackResult(Mapping):
        pass

    class StackAttribute(object):
        pass

    def associate_fleet(self, StackName: str, FleetName: str) -> AssociateFleetResult:
        pass

    def batch_associate_user_stack(self, UserStackAssociations: List[UserStackAssociation]) -> BatchAssociateUserStackResult:
        pass

    def batch_disassociate_user_stack(self, UserStackAssociations: List[UserStackAssociation]) -> BatchDisassociateUserStackResult:
        pass

    def copy_image(self, DestinationRegion: str, DestinationImageName: str, SourceImageName: str, DestinationImageDescription: str=None) -> CopyImageResponse:
        pass

    def create_directory_config(self, ServiceAccountCredentials: ServiceAccountCredentials, OrganizationalUnitDistinguishedNames: List[OrganizationalUnitDistinguishedName], DirectoryName: str) -> CreateDirectoryConfigResult:
        pass

    def create_fleet(self, ComputeCapacity: ComputeCapacity, InstanceType: str, Name: str, ImageName: str=None, ImageArn: str=None, FleetType: str=None, VpcConfig: VpcConfig=None, MaxUserDurationInSeconds: int=None, DisconnectTimeoutInSeconds: int=None, Description: str=None, DisplayName: str=None, EnableDefaultInternetAccess: BooleanObject=None, DomainJoinInfo: DomainJoinInfo=None, Tags: Tags=None) -> CreateFleetResult:
        pass

    def create_image_builder(self, InstanceType: str, Name: str, ImageName: str=None, ImageArn: str=None, Description: str=None, DisplayName: str=None, VpcConfig: VpcConfig=None, EnableDefaultInternetAccess: BooleanObject=None, DomainJoinInfo: DomainJoinInfo=None, AppstreamAgentVersion: str=None, Tags: Tags=None) -> CreateImageBuilderResult:
        pass

    def create_image_builder_streaming_url(self, Name: str, Validity: Long=None) -> CreateImageBuilderStreamingURLResult:
        pass

    def create_stack(self, Name: str, Description: str=None, DisplayName: str=None, StorageConnectors: List[StorageConnector]=None, RedirectURL: str=None, FeedbackURL: str=None, UserSettings: List[UserSetting]=None, ApplicationSettings: ApplicationSettings=None, Tags: Tags=None) -> CreateStackResult:
        pass

    def create_streaming_url(self, UserId: str, FleetName: str, StackName: str, ApplicationId: str=None, Validity: Long=None, SessionContext: str=None) -> CreateStreamingURLResult:
        pass

    def create_user(self, AuthenticationType: str, UserName: str, MessageAction: str=None, FirstName: str=None, LastName: str=None) -> CreateUserResult:
        pass

    def delete_directory_config(self, DirectoryName: str) -> DeleteDirectoryConfigResult:
        pass

    def delete_fleet(self, Name: str) -> DeleteFleetResult:
        pass

    def delete_image(self, Name: str) -> DeleteImageResult:
        pass

    def delete_image_builder(self, Name: str) -> DeleteImageBuilderResult:
        pass

    def delete_image_permissions(self, SharedAccountId: str, Name: str) -> DeleteImagePermissionsResult:
        pass

    def delete_stack(self, Name: str) -> DeleteStackResult:
        pass

    def delete_user(self, AuthenticationType: str, UserName: str) -> DeleteUserResult:
        pass

    def describe_directory_configs(self, DirectoryNames: List[DirectoryName]=None, MaxResults: int=None, NextToken: str=None) -> DescribeDirectoryConfigsResult:
        pass

    def describe_fleets(self, Names: List[String]=None, NextToken: str=None) -> DescribeFleetsResult:
        pass

    def describe_image_builders(self, Names: List[String]=None, MaxResults: int=None, NextToken: str=None) -> DescribeImageBuildersResult:
        pass

    def describe_image_permissions(self, Name: str, MaxResults: int=None, SharedAwsAccountIds: List[AwsAccountId]=None, NextToken: str=None) -> DescribeImagePermissionsResult:
        pass

    def describe_images(self, Names: List[String]=None, Arns: List[Arn]=None, Type: str=None, NextToken: str=None, MaxResults: int=None) -> DescribeImagesResult:
        pass

    def describe_sessions(self, FleetName: str, StackName: str, UserId: str=None, NextToken: str=None, Limit: int=None, AuthenticationType: str=None) -> DescribeSessionsResult:
        pass

    def describe_stacks(self, Names: List[String]=None, NextToken: str=None) -> DescribeStacksResult:
        pass

    def describe_user_stack_associations(self, StackName: str=None, UserName: str=None, AuthenticationType: str=None, MaxResults: int=None, NextToken: str=None) -> DescribeUserStackAssociationsResult:
        pass

    def describe_users(self, AuthenticationType: str, MaxResults: int=None, NextToken: str=None) -> DescribeUsersResult:
        pass

    def disable_user(self, AuthenticationType: str, UserName: str) -> DisableUserResult:
        pass

    def disassociate_fleet(self, StackName: str, FleetName: str) -> DisassociateFleetResult:
        pass

    def enable_user(self, AuthenticationType: str, UserName: str) -> EnableUserResult:
        pass

    def expire_session(self, SessionId: str) -> ExpireSessionResult:
        pass

    def list_associated_fleets(self, StackName: str, NextToken: str=None) -> ListAssociatedFleetsResult:
        pass

    def list_associated_stacks(self, FleetName: str, NextToken: str=None) -> ListAssociatedStacksResult:
        pass

    def list_tags_for_resource(self, ResourceArn: str) -> ListTagsForResourceResponse:
        pass

    def start_fleet(self, Name: str) -> StartFleetResult:
        pass

    def start_image_builder(self, Name: str, AppstreamAgentVersion: str=None) -> StartImageBuilderResult:
        pass

    def stop_fleet(self, Name: str) -> StopFleetResult:
        pass

    def stop_image_builder(self, Name: str) -> StopImageBuilderResult:
        pass

    def tag_resource(self, Tags: Tags, ResourceArn: str) -> TagResourceResponse:
        pass

    def untag_resource(self, TagKeys: List[TagKey], ResourceArn: str) -> UntagResourceResponse:
        pass

    def update_directory_config(self, DirectoryName: str, OrganizationalUnitDistinguishedNames: List[OrganizationalUnitDistinguishedName]=None, ServiceAccountCredentials: ServiceAccountCredentials=None) -> UpdateDirectoryConfigResult:
        pass

    def update_fleet(self, ImageName: str=None, ImageArn: str=None, Name: str=None, InstanceType: str=None, ComputeCapacity: ComputeCapacity=None, VpcConfig: VpcConfig=None, MaxUserDurationInSeconds: int=None, DisconnectTimeoutInSeconds: int=None, DeleteVpcConfig: Boolean=None, Description: str=None, DisplayName: str=None, EnableDefaultInternetAccess: BooleanObject=None, DomainJoinInfo: DomainJoinInfo=None, AttributesToDelete: List[FleetAttribute]=None) -> UpdateFleetResult:
        pass

    def update_image_permissions(self, ImagePermissions: ImagePermissions, SharedAccountId: str, Name: str) -> UpdateImagePermissionsResult:
        pass

    def update_stack(self, Name: str, DisplayName: str=None, Description: str=None, StorageConnectors: List[StorageConnector]=None, DeleteStorageConnectors: Boolean=None, RedirectURL: str=None, FeedbackURL: str=None, AttributesToDelete: List[StackAttribute]=None, UserSettings: List[UserSetting]=None, ApplicationSettings: ApplicationSettings=None) -> UpdateStackResult:
        pass


class AppSync(BaseClient):
    class CreateApiKeyRequest(Mapping):
        pass

    class CreateApiKeyResponse(Mapping):
        pass

    class Long(object):
        pass

    class CreateDataSourceRequest(Mapping):
        pass

    class CreateDataSourceResponse(Mapping):
        pass

    class DynamodbDataSourceConfig(Mapping):
        pass

    class LambdaDataSourceConfig(Mapping):
        pass

    class ElasticsearchDataSourceConfig(Mapping):
        pass

    class HttpDataSourceConfig(Mapping):
        pass

    class RelationalDatabaseDataSourceConfig(Mapping):
        pass

    class CreateFunctionRequest(Mapping):
        pass

    class CreateFunctionResponse(Mapping):
        pass

    class CreateGraphqlApiRequest(Mapping):
        pass

    class CreateGraphqlApiResponse(Mapping):
        pass

    class LogConfig(Mapping):
        pass

    class UserPoolConfig(Mapping):
        pass

    class OpenIDConnectConfig(Mapping):
        pass

    class CreateResolverRequest(Mapping):
        pass

    class CreateResolverResponse(Mapping):
        pass

    class PipelineConfig(Mapping):
        pass

    class CreateTypeRequest(Mapping):
        pass

    class CreateTypeResponse(Mapping):
        pass

    class DeleteApiKeyRequest(Mapping):
        pass

    class DeleteApiKeyResponse(Mapping):
        pass

    class DeleteDataSourceRequest(Mapping):
        pass

    class DeleteDataSourceResponse(Mapping):
        pass

    class DeleteFunctionRequest(Mapping):
        pass

    class DeleteFunctionResponse(Mapping):
        pass

    class DeleteGraphqlApiRequest(Mapping):
        pass

    class DeleteGraphqlApiResponse(Mapping):
        pass

    class DeleteResolverRequest(Mapping):
        pass

    class DeleteResolverResponse(Mapping):
        pass

    class DeleteTypeRequest(Mapping):
        pass

    class DeleteTypeResponse(Mapping):
        pass

    class GetDataSourceRequest(Mapping):
        pass

    class GetDataSourceResponse(Mapping):
        pass

    class GetFunctionRequest(Mapping):
        pass

    class GetFunctionResponse(Mapping):
        pass

    class GetGraphqlApiRequest(Mapping):
        pass

    class GetGraphqlApiResponse(Mapping):
        pass

    class GetIntrospectionSchemaRequest(Mapping):
        pass

    class GetIntrospectionSchemaResponse(Mapping):
        pass

    class GetResolverRequest(Mapping):
        pass

    class GetResolverResponse(Mapping):
        pass

    class GetSchemaCreationStatusRequest(Mapping):
        pass

    class GetSchemaCreationStatusResponse(Mapping):
        pass

    class GetTypeRequest(Mapping):
        pass

    class GetTypeResponse(Mapping):
        pass

    class ListApiKeysRequest(Mapping):
        pass

    class ListApiKeysResponse(Mapping):
        pass

    class ListDataSourcesRequest(Mapping):
        pass

    class ListDataSourcesResponse(Mapping):
        pass

    class ListFunctionsRequest(Mapping):
        pass

    class ListFunctionsResponse(Mapping):
        pass

    class ListGraphqlApisRequest(Mapping):
        pass

    class ListGraphqlApisResponse(Mapping):
        pass

    class ListResolversRequest(Mapping):
        pass

    class ListResolversResponse(Mapping):
        pass

    class ListResolversByFunctionRequest(Mapping):
        pass

    class ListResolversByFunctionResponse(Mapping):
        pass

    class ListTypesRequest(Mapping):
        pass

    class ListTypesResponse(Mapping):
        pass

    class StartSchemaCreationRequest(Mapping):
        pass

    class StartSchemaCreationResponse(Mapping):
        pass

    class Blob(object):
        pass

    class UpdateApiKeyRequest(Mapping):
        pass

    class UpdateApiKeyResponse(Mapping):
        pass

    class UpdateDataSourceRequest(Mapping):
        pass

    class UpdateDataSourceResponse(Mapping):
        pass

    class UpdateFunctionRequest(Mapping):
        pass

    class UpdateFunctionResponse(Mapping):
        pass

    class UpdateGraphqlApiRequest(Mapping):
        pass

    class UpdateGraphqlApiResponse(Mapping):
        pass

    class UpdateResolverRequest(Mapping):
        pass

    class UpdateResolverResponse(Mapping):
        pass

    class UpdateTypeRequest(Mapping):
        pass

    class UpdateTypeResponse(Mapping):
        pass

    def create_api_key(self, apiId: str, description: str=None, expires: Long=None) -> CreateApiKeyResponse:
        pass

    def create_data_source(self, type: str, name: str, apiId: str, description: str=None, serviceRoleArn: str=None, dynamodbConfig: DynamodbDataSourceConfig=None, lambdaConfig: LambdaDataSourceConfig=None, elasticsearchConfig: ElasticsearchDataSourceConfig=None, httpConfig: HttpDataSourceConfig=None, relationalDatabaseConfig: RelationalDatabaseDataSourceConfig=None) -> CreateDataSourceResponse:
        pass

    def create_function(self, functionVersion: str, requestMappingTemplate: str, dataSourceName: str, name: str, apiId: str, description: str=None, responseMappingTemplate: str=None) -> CreateFunctionResponse:
        pass

    def create_graphql_api(self, authenticationType: str, name: str, logConfig: LogConfig=None, userPoolConfig: UserPoolConfig=None, openIDConnectConfig: OpenIDConnectConfig=None) -> CreateGraphqlApiResponse:
        pass

    def create_resolver(self, requestMappingTemplate: str, fieldName: str, typeName: str, apiId: str, dataSourceName: str=None, responseMappingTemplate: str=None, kind: str=None, pipelineConfig: PipelineConfig=None) -> CreateResolverResponse:
        pass

    def create_type(self, format: str, definition: str, apiId: str) -> CreateTypeResponse:
        pass

    def delete_api_key(self, id: str, apiId: str) -> DeleteApiKeyResponse:
        pass

    def delete_data_source(self, name: str, apiId: str) -> DeleteDataSourceResponse:
        pass

    def delete_function(self, functionId: str, apiId: str) -> DeleteFunctionResponse:
        pass

    def delete_graphql_api(self, apiId: str) -> DeleteGraphqlApiResponse:
        pass

    def delete_resolver(self, fieldName: str, typeName: str, apiId: str) -> DeleteResolverResponse:
        pass

    def delete_type(self, typeName: str, apiId: str) -> DeleteTypeResponse:
        pass

    def get_data_source(self, name: str, apiId: str) -> GetDataSourceResponse:
        pass

    def get_function(self, functionId: str, apiId: str) -> GetFunctionResponse:
        pass

    def get_graphql_api(self, apiId: str) -> GetGraphqlApiResponse:
        pass

    def get_introspection_schema(self, format: str, apiId: str) -> GetIntrospectionSchemaResponse:
        pass

    def get_resolver(self, fieldName: str, typeName: str, apiId: str) -> GetResolverResponse:
        pass

    def get_schema_creation_status(self, apiId: str) -> GetSchemaCreationStatusResponse:
        pass

    def get_type(self, format: str, typeName: str, apiId: str) -> GetTypeResponse:
        pass

    def list_api_keys(self, apiId: str, nextToken: str=None, maxResults: int=None) -> ListApiKeysResponse:
        pass

    def list_data_sources(self, apiId: str, nextToken: str=None, maxResults: int=None) -> ListDataSourcesResponse:
        pass

    def list_functions(self, apiId: str, nextToken: str=None, maxResults: int=None) -> ListFunctionsResponse:
        pass

    def list_graphql_apis(self, nextToken: str=None, maxResults: int=None) -> ListGraphqlApisResponse:
        pass

    def list_resolvers(self, typeName: str, apiId: str, nextToken: str=None, maxResults: int=None) -> ListResolversResponse:
        pass

    def list_resolvers_by_function(self, functionId: str, apiId: str, nextToken: str=None, maxResults: int=None) -> ListResolversByFunctionResponse:
        pass

    def list_types(self, format: str, apiId: str, nextToken: str=None, maxResults: int=None) -> ListTypesResponse:
        pass

    def start_schema_creation(self, definition: Blob, apiId: str) -> StartSchemaCreationResponse:
        pass

    def update_api_key(self, id: str, apiId: str, description: str=None, expires: Long=None) -> UpdateApiKeyResponse:
        pass

    def update_data_source(self, type: str, name: str, apiId: str, description: str=None, serviceRoleArn: str=None, dynamodbConfig: DynamodbDataSourceConfig=None, lambdaConfig: LambdaDataSourceConfig=None, elasticsearchConfig: ElasticsearchDataSourceConfig=None, httpConfig: HttpDataSourceConfig=None, relationalDatabaseConfig: RelationalDatabaseDataSourceConfig=None) -> UpdateDataSourceResponse:
        pass

    def update_function(self, functionVersion: str, requestMappingTemplate: str, dataSourceName: str, functionId: str, name: str, apiId: str, description: str=None, responseMappingTemplate: str=None) -> UpdateFunctionResponse:
        pass

    def update_graphql_api(self, name: str, apiId: str, logConfig: LogConfig=None, authenticationType: str=None, userPoolConfig: UserPoolConfig=None, openIDConnectConfig: OpenIDConnectConfig=None) -> UpdateGraphqlApiResponse:
        pass

    def update_resolver(self, requestMappingTemplate: str, fieldName: str, typeName: str, apiId: str, dataSourceName: str=None, responseMappingTemplate: str=None, kind: str=None, pipelineConfig: PipelineConfig=None) -> UpdateResolverResponse:
        pass

    def update_type(self, format: str, typeName: str, apiId: str, definition: str=None) -> UpdateTypeResponse:
        pass


class Athena(BaseClient):
    class BatchGetNamedQueryInput(Mapping):
        pass

    class BatchGetNamedQueryOutput(Mapping):
        pass

    class NamedQueryId(object):
        pass

    class BatchGetQueryExecutionInput(Mapping):
        pass

    class BatchGetQueryExecutionOutput(Mapping):
        pass

    class QueryExecutionId(object):
        pass

    class CreateNamedQueryInput(Mapping):
        pass

    class CreateNamedQueryOutput(Mapping):
        pass

    class DeleteNamedQueryInput(Mapping):
        pass

    class DeleteNamedQueryOutput(Mapping):
        pass

    class GetNamedQueryInput(Mapping):
        pass

    class GetNamedQueryOutput(Mapping):
        pass

    class GetQueryExecutionInput(Mapping):
        pass

    class GetQueryExecutionOutput(Mapping):
        pass

    class GetQueryResultsInput(Mapping):
        pass

    class GetQueryResultsOutput(Mapping):
        pass

    class ListNamedQueriesInput(Mapping):
        pass

    class ListNamedQueriesOutput(Mapping):
        pass

    class ListQueryExecutionsInput(Mapping):
        pass

    class ListQueryExecutionsOutput(Mapping):
        pass

    class StartQueryExecutionInput(Mapping):
        pass

    class StartQueryExecutionOutput(Mapping):
        pass

    class QueryExecutionContext(Mapping):
        pass

    class ResultConfiguration(Mapping):
        pass

    class StopQueryExecutionInput(Mapping):
        pass

    class StopQueryExecutionOutput(Mapping):
        pass

    def batch_get_named_query(self, NamedQueryIds: List[NamedQueryId]) -> BatchGetNamedQueryOutput:
        pass

    def batch_get_query_execution(self, QueryExecutionIds: List[QueryExecutionId]) -> BatchGetQueryExecutionOutput:
        pass

    def create_named_query(self, QueryString: str, Database: str, Name: str, Description: str=None, ClientRequestToken: str=None) -> CreateNamedQueryOutput:
        pass

    def delete_named_query(self, NamedQueryId: str) -> DeleteNamedQueryOutput:
        pass

    def get_named_query(self, NamedQueryId: str) -> GetNamedQueryOutput:
        pass

    def get_query_execution(self, QueryExecutionId: str) -> GetQueryExecutionOutput:
        pass

    def get_query_results(self, QueryExecutionId: str, NextToken: str=None, MaxResults: int=None) -> GetQueryResultsOutput:
        pass

    def list_named_queries(self, NextToken: str=None, MaxResults: int=None) -> ListNamedQueriesOutput:
        pass

    def list_query_executions(self, NextToken: str=None, MaxResults: int=None) -> ListQueryExecutionsOutput:
        pass

    def start_query_execution(self, ResultConfiguration: ResultConfiguration, QueryString: str, ClientRequestToken: str=None, QueryExecutionContext: QueryExecutionContext=None) -> StartQueryExecutionOutput:
        pass

    def stop_query_execution(self, QueryExecutionId: str) -> StopQueryExecutionOutput:
        pass


class AutoScaling(BaseClient):
    class AttachInstancesQuery(Mapping):
        pass

    class XmlStringMaxLen19(object):
        pass

    class AttachLoadBalancerTargetGroupsType(Mapping):
        pass

    class AttachLoadBalancerTargetGroupsResultType(Mapping):
        pass

    class XmlStringMaxLen511(object):
        pass

    class AttachLoadBalancersType(Mapping):
        pass

    class AttachLoadBalancersResultType(Mapping):
        pass

    class XmlStringMaxLen255(object):
        pass

    class BatchDeleteScheduledActionType(Mapping):
        pass

    class BatchDeleteScheduledActionAnswer(Mapping):
        pass

    class ResourceName(object):
        pass

    class BatchPutScheduledUpdateGroupActionType(Mapping):
        pass

    class BatchPutScheduledUpdateGroupActionAnswer(Mapping):
        pass

    class ScheduledUpdateGroupActionRequest(Mapping):
        pass

    class CompleteLifecycleActionType(Mapping):
        pass

    class CompleteLifecycleActionAnswer(Mapping):
        pass

    class CreateAutoScalingGroupType(Mapping):
        pass

    class LaunchTemplateSpecification(Mapping):
        pass

    class MixedInstancesPolicy(Mapping):
        pass

    class XmlStringMaxLen1600(object):
        pass

    class InstanceProtected(object):
        pass

    class LifecycleHookSpecification(Mapping):
        pass

    class Tag(Mapping):
        pass

    class CreateLaunchConfigurationType(Mapping):
        pass

    class XmlString(object):
        pass

    class BlockDeviceMapping(Mapping):
        pass

    class InstanceMonitoring(Mapping):
        pass

    class EbsOptimized(object):
        pass

    class AssociatePublicIpAddress(object):
        pass

    class CreateOrUpdateTagsType(Mapping):
        pass

    class DeleteAutoScalingGroupType(Mapping):
        pass

    class ForceDelete(object):
        pass

    class LaunchConfigurationNameType(Mapping):
        pass

    class DeleteLifecycleHookType(Mapping):
        pass

    class DeleteLifecycleHookAnswer(Mapping):
        pass

    class DeleteNotificationConfigurationType(Mapping):
        pass

    class DeletePolicyType(Mapping):
        pass

    class DeleteScheduledActionType(Mapping):
        pass

    class DeleteTagsType(Mapping):
        pass

    class DescribeAccountLimitsAnswer(Mapping):
        pass

    class DescribeAdjustmentTypesAnswer(Mapping):
        pass

    class AutoScalingGroupNamesType(Mapping):
        pass

    class AutoScalingGroupsType(Mapping):
        pass

    class DescribeAutoScalingInstancesType(Mapping):
        pass

    class AutoScalingInstancesType(Mapping):
        pass

    class DescribeAutoScalingNotificationTypesAnswer(Mapping):
        pass

    class LaunchConfigurationNamesType(Mapping):
        pass

    class LaunchConfigurationsType(Mapping):
        pass

    class DescribeLifecycleHookTypesAnswer(Mapping):
        pass

    class DescribeLifecycleHooksType(Mapping):
        pass

    class DescribeLifecycleHooksAnswer(Mapping):
        pass

    class AsciiStringMaxLen255(object):
        pass

    class DescribeLoadBalancerTargetGroupsRequest(Mapping):
        pass

    class DescribeLoadBalancerTargetGroupsResponse(Mapping):
        pass

    class DescribeLoadBalancersRequest(Mapping):
        pass

    class DescribeLoadBalancersResponse(Mapping):
        pass

    class DescribeMetricCollectionTypesAnswer(Mapping):
        pass

    class DescribeNotificationConfigurationsType(Mapping):
        pass

    class DescribeNotificationConfigurationsAnswer(Mapping):
        pass

    class DescribePoliciesType(Mapping):
        pass

    class PoliciesType(Mapping):
        pass

    class XmlStringMaxLen64(object):
        pass

    class DescribeScalingActivitiesType(Mapping):
        pass

    class ActivitiesType(Mapping):
        pass

    class ProcessesType(Mapping):
        pass

    class DescribeScheduledActionsType(Mapping):
        pass

    class ScheduledActionsType(Mapping):
        pass

    class TimestampType(object):
        pass

    class DescribeTagsType(Mapping):
        pass

    class TagsType(Mapping):
        pass

    class Filter(Mapping):
        pass

    class DescribeTerminationPolicyTypesAnswer(Mapping):
        pass

    class DetachInstancesQuery(Mapping):
        pass

    class DetachInstancesAnswer(Mapping):
        pass

    class ShouldDecrementDesiredCapacity(object):
        pass

    class DetachLoadBalancerTargetGroupsType(Mapping):
        pass

    class DetachLoadBalancerTargetGroupsResultType(Mapping):
        pass

    class DetachLoadBalancersType(Mapping):
        pass

    class DetachLoadBalancersResultType(Mapping):
        pass

    class DisableMetricsCollectionQuery(Mapping):
        pass

    class EnableMetricsCollectionQuery(Mapping):
        pass

    class EnterStandbyQuery(Mapping):
        pass

    class EnterStandbyAnswer(Mapping):
        pass

    class ExecutePolicyType(Mapping):
        pass

    class HonorCooldown(object):
        pass

    class MetricScale(object):
        pass

    class ExitStandbyQuery(Mapping):
        pass

    class ExitStandbyAnswer(Mapping):
        pass

    class PutLifecycleHookType(Mapping):
        pass

    class PutLifecycleHookAnswer(Mapping):
        pass

    class PutNotificationConfigurationType(Mapping):
        pass

    class PutScalingPolicyType(Mapping):
        pass

    class PolicyARNType(Mapping):
        pass

    class StepAdjustment(Mapping):
        pass

    class TargetTrackingConfiguration(Mapping):
        pass

    class PutScheduledUpdateGroupActionType(Mapping):
        pass

    class RecordLifecycleActionHeartbeatType(Mapping):
        pass

    class RecordLifecycleActionHeartbeatAnswer(Mapping):
        pass

    class ScalingProcessQuery(Mapping):
        pass

    class SetDesiredCapacityType(Mapping):
        pass

    class SetInstanceHealthQuery(Mapping):
        pass

    class ShouldRespectGracePeriod(object):
        pass

    class SetInstanceProtectionQuery(Mapping):
        pass

    class SetInstanceProtectionAnswer(Mapping):
        pass

    class ProtectedFromScaleIn(object):
        pass

    class TerminateInstanceInAutoScalingGroupType(Mapping):
        pass

    class ActivityType(Mapping):
        pass

    class UpdateAutoScalingGroupType(Mapping):
        pass

    def attach_instances(self, AutoScalingGroupName: str, InstanceIds: List[XmlStringMaxLen19]=None):
        pass

    def attach_load_balancer_target_groups(self, TargetGroupARNs: List[XmlStringMaxLen511], AutoScalingGroupName: str) -> AttachLoadBalancerTargetGroupsResultType:
        pass

    def attach_load_balancers(self, LoadBalancerNames: List[XmlStringMaxLen255], AutoScalingGroupName: str) -> AttachLoadBalancersResultType:
        pass

    def batch_delete_scheduled_action(self, ScheduledActionNames: List[ResourceName], AutoScalingGroupName: str) -> BatchDeleteScheduledActionAnswer:
        pass

    def batch_put_scheduled_update_group_action(self, ScheduledUpdateGroupActions: List[ScheduledUpdateGroupActionRequest], AutoScalingGroupName: str) -> BatchPutScheduledUpdateGroupActionAnswer:
        pass

    def complete_lifecycle_action(self, LifecycleActionResult: str, AutoScalingGroupName: str, LifecycleHookName: str, LifecycleActionToken: str=None, InstanceId: str=None) -> CompleteLifecycleActionAnswer:
        pass

    def create_auto_scaling_group(self, MaxSize: int, MinSize: int, AutoScalingGroupName: str, LaunchConfigurationName: str=None, LaunchTemplate: LaunchTemplateSpecification=None, MixedInstancesPolicy: MixedInstancesPolicy=None, InstanceId: str=None, DesiredCapacity: int=None, DefaultCooldown: int=None, AvailabilityZones: List[XmlStringMaxLen255]=None, LoadBalancerNames: List[XmlStringMaxLen255]=None, TargetGroupARNs: List[XmlStringMaxLen511]=None, HealthCheckType: str=None, HealthCheckGracePeriod: int=None, PlacementGroup: str=None, VPCZoneIdentifier: str=None, TerminationPolicies: List[XmlStringMaxLen1600]=None, NewInstancesProtectedFromScaleIn: InstanceProtected=None, LifecycleHookSpecificationList: List[LifecycleHookSpecification]=None, Tags: List[Tag]=None, ServiceLinkedRoleARN: str=None):
        pass

    def create_launch_configuration(self, LaunchConfigurationName: str, ImageId: str=None, KeyName: str=None, SecurityGroups: List[XmlString]=None, ClassicLinkVPCId: str=None, ClassicLinkVPCSecurityGroups: List[XmlStringMaxLen255]=None, UserData: str=None, InstanceId: str=None, InstanceType: str=None, KernelId: str=None, RamdiskId: str=None, BlockDeviceMappings: List[BlockDeviceMapping]=None, InstanceMonitoring: InstanceMonitoring=None, SpotPrice: str=None, IamInstanceProfile: str=None, EbsOptimized: EbsOptimized=None, AssociatePublicIpAddress: AssociatePublicIpAddress=None, PlacementTenancy: str=None):
        pass

    def create_or_update_tags(self, Tags: List[Tag]):
        pass

    def delete_auto_scaling_group(self, AutoScalingGroupName: str, ForceDelete: ForceDelete=None):
        pass

    def delete_launch_configuration(self, LaunchConfigurationName: str):
        pass

    def delete_lifecycle_hook(self, AutoScalingGroupName: str, LifecycleHookName: str) -> DeleteLifecycleHookAnswer:
        pass

    def delete_notification_configuration(self, TopicARN: str, AutoScalingGroupName: str):
        pass

    def delete_policy(self, PolicyName: str, AutoScalingGroupName: str=None):
        pass

    def delete_scheduled_action(self, ScheduledActionName: str, AutoScalingGroupName: str):
        pass

    def delete_tags(self, Tags: List[Tag]):
        pass

    def describe_account_limits(self) -> DescribeAccountLimitsAnswer:
        pass

    def describe_adjustment_types(self) -> DescribeAdjustmentTypesAnswer:
        pass

    def describe_auto_scaling_groups(self, AutoScalingGroupNames: List[ResourceName]=None, NextToken: str=None, MaxRecords: int=None) -> AutoScalingGroupsType:
        pass

    def describe_auto_scaling_instances(self, InstanceIds: List[XmlStringMaxLen19]=None, MaxRecords: int=None, NextToken: str=None) -> AutoScalingInstancesType:
        pass

    def describe_auto_scaling_notification_types(self) -> DescribeAutoScalingNotificationTypesAnswer:
        pass

    def describe_launch_configurations(self, LaunchConfigurationNames: List[ResourceName]=None, NextToken: str=None, MaxRecords: int=None) -> LaunchConfigurationsType:
        pass

    def describe_lifecycle_hook_types(self) -> DescribeLifecycleHookTypesAnswer:
        pass

    def describe_lifecycle_hooks(self, AutoScalingGroupName: str, LifecycleHookNames: List[AsciiStringMaxLen255]=None) -> DescribeLifecycleHooksAnswer:
        pass

    def describe_load_balancer_target_groups(self, AutoScalingGroupName: str, NextToken: str=None, MaxRecords: int=None) -> DescribeLoadBalancerTargetGroupsResponse:
        pass

    def describe_load_balancers(self, AutoScalingGroupName: str, NextToken: str=None, MaxRecords: int=None) -> DescribeLoadBalancersResponse:
        pass

    def describe_metric_collection_types(self) -> DescribeMetricCollectionTypesAnswer:
        pass

    def describe_notification_configurations(self, AutoScalingGroupNames: List[ResourceName]=None, NextToken: str=None, MaxRecords: int=None) -> DescribeNotificationConfigurationsAnswer:
        pass

    def describe_policies(self, AutoScalingGroupName: str=None, PolicyNames: List[ResourceName]=None, PolicyTypes: List[XmlStringMaxLen64]=None, NextToken: str=None, MaxRecords: int=None) -> PoliciesType:
        pass

    def describe_scaling_activities(self, ActivityIds: List[XmlString]=None, AutoScalingGroupName: str=None, MaxRecords: int=None, NextToken: str=None) -> ActivitiesType:
        pass

    def describe_scaling_process_types(self) -> ProcessesType:
        pass

    def describe_scheduled_actions(self, AutoScalingGroupName: str=None, ScheduledActionNames: List[ResourceName]=None, StartTime: TimestampType=None, EndTime: TimestampType=None, NextToken: str=None, MaxRecords: int=None) -> ScheduledActionsType:
        pass

    def describe_tags(self, Filters: List[Filter]=None, NextToken: str=None, MaxRecords: int=None) -> TagsType:
        pass

    def describe_termination_policy_types(self) -> DescribeTerminationPolicyTypesAnswer:
        pass

    def detach_instances(self, ShouldDecrementDesiredCapacity: ShouldDecrementDesiredCapacity, AutoScalingGroupName: str, InstanceIds: List[XmlStringMaxLen19]=None) -> DetachInstancesAnswer:
        pass

    def detach_load_balancer_target_groups(self, TargetGroupARNs: List[XmlStringMaxLen511], AutoScalingGroupName: str) -> DetachLoadBalancerTargetGroupsResultType:
        pass

    def detach_load_balancers(self, LoadBalancerNames: List[XmlStringMaxLen255], AutoScalingGroupName: str) -> DetachLoadBalancersResultType:
        pass

    def disable_metrics_collection(self, AutoScalingGroupName: str, Metrics: List[XmlStringMaxLen255]=None):
        pass

    def enable_metrics_collection(self, Granularity: str, AutoScalingGroupName: str, Metrics: List[XmlStringMaxLen255]=None):
        pass

    def enter_standby(self, ShouldDecrementDesiredCapacity: ShouldDecrementDesiredCapacity, AutoScalingGroupName: str, InstanceIds: List[XmlStringMaxLen19]=None) -> EnterStandbyAnswer:
        pass

    def execute_policy(self, PolicyName: str, AutoScalingGroupName: str=None, HonorCooldown: HonorCooldown=None, MetricValue: MetricScale=None, BreachThreshold: MetricScale=None):
        pass

    def exit_standby(self, AutoScalingGroupName: str, InstanceIds: List[XmlStringMaxLen19]=None) -> ExitStandbyAnswer:
        pass

    def put_lifecycle_hook(self, AutoScalingGroupName: str, LifecycleHookName: str, LifecycleTransition: str=None, RoleARN: str=None, NotificationTargetARN: str=None, NotificationMetadata: str=None, HeartbeatTimeout: int=None, DefaultResult: str=None) -> PutLifecycleHookAnswer:
        pass

    def put_notification_configuration(self, NotificationTypes: List[XmlStringMaxLen255], TopicARN: str, AutoScalingGroupName: str):
        pass

    def put_scaling_policy(self, PolicyName: str, AutoScalingGroupName: str, PolicyType: str=None, AdjustmentType: str=None, MinAdjustmentStep: int=None, MinAdjustmentMagnitude: int=None, ScalingAdjustment: int=None, Cooldown: int=None, MetricAggregationType: str=None, StepAdjustments: List[StepAdjustment]=None, EstimatedInstanceWarmup: int=None, TargetTrackingConfiguration: TargetTrackingConfiguration=None) -> PolicyARNType:
        pass

    def put_scheduled_update_group_action(self, ScheduledActionName: str, AutoScalingGroupName: str, Time: TimestampType=None, StartTime: TimestampType=None, EndTime: TimestampType=None, Recurrence: str=None, MinSize: int=None, MaxSize: int=None, DesiredCapacity: int=None):
        pass

    def record_lifecycle_action_heartbeat(self, AutoScalingGroupName: str, LifecycleHookName: str, LifecycleActionToken: str=None, InstanceId: str=None) -> RecordLifecycleActionHeartbeatAnswer:
        pass

    def resume_processes(self, AutoScalingGroupName: str, ScalingProcesses: List[XmlStringMaxLen255]=None):
        pass

    def set_desired_capacity(self, DesiredCapacity: int, AutoScalingGroupName: str, HonorCooldown: HonorCooldown=None):
        pass

    def set_instance_health(self, HealthStatus: str, InstanceId: str, ShouldRespectGracePeriod: ShouldRespectGracePeriod=None):
        pass

    def set_instance_protection(self, ProtectedFromScaleIn: ProtectedFromScaleIn, AutoScalingGroupName: str, InstanceIds: List[XmlStringMaxLen19]) -> SetInstanceProtectionAnswer:
        pass

    def suspend_processes(self, AutoScalingGroupName: str, ScalingProcesses: List[XmlStringMaxLen255]=None):
        pass

    def terminate_instance_in_auto_scaling_group(self, ShouldDecrementDesiredCapacity: ShouldDecrementDesiredCapacity, InstanceId: str) -> ActivityType:
        pass

    def update_auto_scaling_group(self, AutoScalingGroupName: str, LaunchConfigurationName: str=None, LaunchTemplate: LaunchTemplateSpecification=None, MixedInstancesPolicy: MixedInstancesPolicy=None, MinSize: int=None, MaxSize: int=None, DesiredCapacity: int=None, DefaultCooldown: int=None, AvailabilityZones: List[XmlStringMaxLen255]=None, HealthCheckType: str=None, HealthCheckGracePeriod: int=None, PlacementGroup: str=None, VPCZoneIdentifier: str=None, TerminationPolicies: List[XmlStringMaxLen1600]=None, NewInstancesProtectedFromScaleIn: InstanceProtected=None, ServiceLinkedRoleARN: str=None):
        pass


class AutoScalingPlans(BaseClient):
    class CreateScalingPlanRequest(Mapping):
        pass

    class CreateScalingPlanResponse(Mapping):
        pass

    class ApplicationSource(Mapping):
        pass

    class ScalingInstruction(Mapping):
        pass

    class DeleteScalingPlanRequest(Mapping):
        pass

    class DeleteScalingPlanResponse(Mapping):
        pass

    class ScalingPlanVersion(object):
        pass

    class DescribeScalingPlanResourcesRequest(Mapping):
        pass

    class DescribeScalingPlanResourcesResponse(Mapping):
        pass

    class DescribeScalingPlansRequest(Mapping):
        pass

    class DescribeScalingPlansResponse(Mapping):
        pass

    class ScalingPlanName(object):
        pass

    class GetScalingPlanResourceForecastDataRequest(Mapping):
        pass

    class GetScalingPlanResourceForecastDataResponse(Mapping):
        pass

    class TimestampType(object):
        pass

    class UpdateScalingPlanRequest(Mapping):
        pass

    class UpdateScalingPlanResponse(Mapping):
        pass

    def create_scaling_plan(self, ScalingInstructions: List[ScalingInstruction], ApplicationSource: ApplicationSource, ScalingPlanName: str) -> CreateScalingPlanResponse:
        pass

    def delete_scaling_plan(self, ScalingPlanVersion: ScalingPlanVersion, ScalingPlanName: str) -> DeleteScalingPlanResponse:
        pass

    def describe_scaling_plan_resources(self, ScalingPlanVersion: ScalingPlanVersion, ScalingPlanName: str, MaxResults: int=None, NextToken: str=None) -> DescribeScalingPlanResourcesResponse:
        pass

    def describe_scaling_plans(self, ScalingPlanNames: List[ScalingPlanName]=None, ScalingPlanVersion: ScalingPlanVersion=None, ApplicationSources: List[ApplicationSource]=None, MaxResults: int=None, NextToken: str=None) -> DescribeScalingPlansResponse:
        pass

    def get_scaling_plan_resource_forecast_data(self, EndTime: TimestampType, StartTime: TimestampType, ForecastDataType: str, ScalableDimension: str, ResourceId: str, ServiceNamespace: str, ScalingPlanVersion: ScalingPlanVersion, ScalingPlanName: str) -> GetScalingPlanResourceForecastDataResponse:
        pass

    def update_scaling_plan(self, ScalingPlanVersion: ScalingPlanVersion, ScalingPlanName: str, ApplicationSource: ApplicationSource=None, ScalingInstructions: List[ScalingInstruction]=None) -> UpdateScalingPlanResponse:
        pass


class Backup(BaseClient):
    class CreateBackupPlanInput(Mapping):
        pass

    class CreateBackupPlanOutput(Mapping):
        pass

    class BackupPlanInput(Mapping):
        pass

    class Tags(object):
        pass

    class CreateBackupSelectionInput(Mapping):
        pass

    class CreateBackupSelectionOutput(Mapping):
        pass

    class BackupSelection(Mapping):
        pass

    class CreateBackupVaultInput(Mapping):
        pass

    class CreateBackupVaultOutput(Mapping):
        pass

    class DeleteBackupPlanInput(Mapping):
        pass

    class DeleteBackupPlanOutput(Mapping):
        pass

    class DeleteBackupSelectionInput(Mapping):
        pass

    class DeleteBackupVaultInput(Mapping):
        pass

    class DeleteBackupVaultAccessPolicyInput(Mapping):
        pass

    class DeleteBackupVaultNotificationsInput(Mapping):
        pass

    class DeleteRecoveryPointInput(Mapping):
        pass

    class DescribeBackupJobInput(Mapping):
        pass

    class DescribeBackupJobOutput(Mapping):
        pass

    class DescribeBackupVaultInput(Mapping):
        pass

    class DescribeBackupVaultOutput(Mapping):
        pass

    class DescribeProtectedResourceInput(Mapping):
        pass

    class DescribeProtectedResourceOutput(Mapping):
        pass

    class DescribeRecoveryPointInput(Mapping):
        pass

    class DescribeRecoveryPointOutput(Mapping):
        pass

    class DescribeRestoreJobInput(Mapping):
        pass

    class DescribeRestoreJobOutput(Mapping):
        pass

    class ExportBackupPlanTemplateInput(Mapping):
        pass

    class ExportBackupPlanTemplateOutput(Mapping):
        pass

    class GetBackupPlanInput(Mapping):
        pass

    class GetBackupPlanOutput(Mapping):
        pass

    class GetBackupPlanFromJSONInput(Mapping):
        pass

    class GetBackupPlanFromJSONOutput(Mapping):
        pass

    class GetBackupPlanFromTemplateInput(Mapping):
        pass

    class GetBackupPlanFromTemplateOutput(Mapping):
        pass

    class GetBackupSelectionInput(Mapping):
        pass

    class GetBackupSelectionOutput(Mapping):
        pass

    class GetBackupVaultAccessPolicyInput(Mapping):
        pass

    class GetBackupVaultAccessPolicyOutput(Mapping):
        pass

    class GetBackupVaultNotificationsInput(Mapping):
        pass

    class GetBackupVaultNotificationsOutput(Mapping):
        pass

    class GetRecoveryPointRestoreMetadataInput(Mapping):
        pass

    class GetRecoveryPointRestoreMetadataOutput(Mapping):
        pass

    class GetSupportedResourceTypesOutput(Mapping):
        pass

    class ListBackupJobsInput(Mapping):
        pass

    class ListBackupJobsOutput(Mapping):
        pass

    class timestamp(object):
        pass

    class ListBackupPlanTemplatesInput(Mapping):
        pass

    class ListBackupPlanTemplatesOutput(Mapping):
        pass

    class ListBackupPlanVersionsInput(Mapping):
        pass

    class ListBackupPlanVersionsOutput(Mapping):
        pass

    class ListBackupPlansInput(Mapping):
        pass

    class ListBackupPlansOutput(Mapping):
        pass

    class Boolean(object):
        pass

    class ListBackupSelectionsInput(Mapping):
        pass

    class ListBackupSelectionsOutput(Mapping):
        pass

    class ListBackupVaultsInput(Mapping):
        pass

    class ListBackupVaultsOutput(Mapping):
        pass

    class ListProtectedResourcesInput(Mapping):
        pass

    class ListProtectedResourcesOutput(Mapping):
        pass

    class ListRecoveryPointsByBackupVaultInput(Mapping):
        pass

    class ListRecoveryPointsByBackupVaultOutput(Mapping):
        pass

    class ListRecoveryPointsByResourceInput(Mapping):
        pass

    class ListRecoveryPointsByResourceOutput(Mapping):
        pass

    class ListRestoreJobsInput(Mapping):
        pass

    class ListRestoreJobsOutput(Mapping):
        pass

    class ListTagsInput(Mapping):
        pass

    class ListTagsOutput(Mapping):
        pass

    class PutBackupVaultAccessPolicyInput(Mapping):
        pass

    class PutBackupVaultNotificationsInput(Mapping):
        pass

    class BackupVaultEvent(object):
        pass

    class StartBackupJobInput(Mapping):
        pass

    class StartBackupJobOutput(Mapping):
        pass

    class WindowMinutes(object):
        pass

    class Lifecycle(Mapping):
        pass

    class StartRestoreJobInput(Mapping):
        pass

    class StartRestoreJobOutput(Mapping):
        pass

    class Metadata(object):
        pass

    class StopBackupJobInput(Mapping):
        pass

    class TagResourceInput(Mapping):
        pass

    class UntagResourceInput(Mapping):
        pass

    class string(object):
        pass

    class UpdateBackupPlanInput(Mapping):
        pass

    class UpdateBackupPlanOutput(Mapping):
        pass

    class UpdateRecoveryPointLifecycleInput(Mapping):
        pass

    class UpdateRecoveryPointLifecycleOutput(Mapping):
        pass

    def create_backup_plan(self, BackupPlan: BackupPlanInput, BackupPlanTags: Tags=None, CreatorRequestId: str=None) -> CreateBackupPlanOutput:
        pass

    def create_backup_selection(self, BackupSelection: BackupSelection, BackupPlanId: str, CreatorRequestId: str=None) -> CreateBackupSelectionOutput:
        pass

    def create_backup_vault(self, BackupVaultName: str, BackupVaultTags: Tags=None, EncryptionKeyArn: str=None, CreatorRequestId: str=None) -> CreateBackupVaultOutput:
        pass

    def delete_backup_plan(self, BackupPlanId: str) -> DeleteBackupPlanOutput:
        pass

    def delete_backup_selection(self, SelectionId: str, BackupPlanId: str):
        pass

    def delete_backup_vault(self, BackupVaultName: str):
        pass

    def delete_backup_vault_access_policy(self, BackupVaultName: str):
        pass

    def delete_backup_vault_notifications(self, BackupVaultName: str):
        pass

    def delete_recovery_point(self, RecoveryPointArn: str, BackupVaultName: str):
        pass

    def describe_backup_job(self, BackupJobId: str) -> DescribeBackupJobOutput:
        pass

    def describe_backup_vault(self, BackupVaultName: str) -> DescribeBackupVaultOutput:
        pass

    def describe_protected_resource(self, ResourceArn: str) -> DescribeProtectedResourceOutput:
        pass

    def describe_recovery_point(self, RecoveryPointArn: str, BackupVaultName: str) -> DescribeRecoveryPointOutput:
        pass

    def describe_restore_job(self, RestoreJobId: str) -> DescribeRestoreJobOutput:
        pass

    def export_backup_plan_template(self, BackupPlanId: str) -> ExportBackupPlanTemplateOutput:
        pass

    def get_backup_plan(self, BackupPlanId: str, VersionId: str=None) -> GetBackupPlanOutput:
        pass

    def get_backup_plan_from_json(self, BackupPlanTemplateJson: str) -> GetBackupPlanFromJSONOutput:
        pass

    def get_backup_plan_from_template(self, BackupPlanTemplateId: str) -> GetBackupPlanFromTemplateOutput:
        pass

    def get_backup_selection(self, SelectionId: str, BackupPlanId: str) -> GetBackupSelectionOutput:
        pass

    def get_backup_vault_access_policy(self, BackupVaultName: str) -> GetBackupVaultAccessPolicyOutput:
        pass

    def get_backup_vault_notifications(self, BackupVaultName: str) -> GetBackupVaultNotificationsOutput:
        pass

    def get_recovery_point_restore_metadata(self, RecoveryPointArn: str, BackupVaultName: str) -> GetRecoveryPointRestoreMetadataOutput:
        pass

    def get_supported_resource_types(self) -> GetSupportedResourceTypesOutput:
        pass

    def list_backup_jobs(self, NextToken: str=None, MaxResults: int=None, ByResourceArn: str=None, ByState: str=None, ByBackupVaultName: str=None, ByCreatedBefore: timestamp=None, ByCreatedAfter: timestamp=None, ByResourceType: str=None) -> ListBackupJobsOutput:
        pass

    def list_backup_plan_templates(self, NextToken: str=None, MaxResults: int=None) -> ListBackupPlanTemplatesOutput:
        pass

    def list_backup_plan_versions(self, BackupPlanId: str, NextToken: str=None, MaxResults: int=None) -> ListBackupPlanVersionsOutput:
        pass

    def list_backup_plans(self, NextToken: str=None, MaxResults: int=None, IncludeDeleted: Boolean=None) -> ListBackupPlansOutput:
        pass

    def list_backup_selections(self, BackupPlanId: str, NextToken: str=None, MaxResults: int=None) -> ListBackupSelectionsOutput:
        pass

    def list_backup_vaults(self, NextToken: str=None, MaxResults: int=None) -> ListBackupVaultsOutput:
        pass

    def list_protected_resources(self, NextToken: str=None, MaxResults: int=None) -> ListProtectedResourcesOutput:
        pass

    def list_recovery_points_by_backup_vault(self, BackupVaultName: str, NextToken: str=None, MaxResults: int=None, ByResourceArn: str=None, ByResourceType: str=None, ByBackupPlanId: str=None, ByCreatedBefore: timestamp=None, ByCreatedAfter: timestamp=None) -> ListRecoveryPointsByBackupVaultOutput:
        pass

    def list_recovery_points_by_resource(self, ResourceArn: str, NextToken: str=None, MaxResults: int=None) -> ListRecoveryPointsByResourceOutput:
        pass

    def list_restore_jobs(self, NextToken: str=None, MaxResults: int=None) -> ListRestoreJobsOutput:
        pass

    def list_tags(self, ResourceArn: str, NextToken: str=None, MaxResults: int=None) -> ListTagsOutput:
        pass

    def put_backup_vault_access_policy(self, BackupVaultName: str, Policy: str=None):
        pass

    def put_backup_vault_notifications(self, BackupVaultEvents: List[BackupVaultEvent], SNSTopicArn: str, BackupVaultName: str):
        pass

    def start_backup_job(self, IamRoleArn: str, ResourceArn: str, BackupVaultName: str, IdempotencyToken: str=None, StartWindowMinutes: WindowMinutes=None, CompleteWindowMinutes: WindowMinutes=None, Lifecycle: Lifecycle=None, RecoveryPointTags: Tags=None) -> StartBackupJobOutput:
        pass

    def start_restore_job(self, IamRoleArn: str, Metadata: Metadata, RecoveryPointArn: str, IdempotencyToken: str=None, ResourceType: str=None) -> StartRestoreJobOutput:
        pass

    def stop_backup_job(self, BackupJobId: str):
        pass

    def tag_resource(self, Tags: Tags, ResourceArn: str):
        pass

    def untag_resource(self, TagKeyList: List[string], ResourceArn: str):
        pass

    def update_backup_plan(self, BackupPlan: BackupPlanInput, BackupPlanId: str) -> UpdateBackupPlanOutput:
        pass

    def update_recovery_point_lifecycle(self, RecoveryPointArn: str, BackupVaultName: str, Lifecycle: Lifecycle=None) -> UpdateRecoveryPointLifecycleOutput:
        pass


class Batch(BaseClient):
    class CancelJobRequest(Mapping):
        pass

    class CancelJobResponse(Mapping):
        pass

    class CreateComputeEnvironmentRequest(Mapping):
        pass

    class CreateComputeEnvironmentResponse(Mapping):
        pass

    class ComputeResource(Mapping):
        pass

    class CreateJobQueueRequest(Mapping):
        pass

    class CreateJobQueueResponse(Mapping):
        pass

    class ComputeEnvironmentOrder(Mapping):
        pass

    class DeleteComputeEnvironmentRequest(Mapping):
        pass

    class DeleteComputeEnvironmentResponse(Mapping):
        pass

    class DeleteJobQueueRequest(Mapping):
        pass

    class DeleteJobQueueResponse(Mapping):
        pass

    class DeregisterJobDefinitionRequest(Mapping):
        pass

    class DeregisterJobDefinitionResponse(Mapping):
        pass

    class DescribeComputeEnvironmentsRequest(Mapping):
        pass

    class DescribeComputeEnvironmentsResponse(Mapping):
        pass

    class String(object):
        pass

    class DescribeJobDefinitionsRequest(Mapping):
        pass

    class DescribeJobDefinitionsResponse(Mapping):
        pass

    class DescribeJobQueuesRequest(Mapping):
        pass

    class DescribeJobQueuesResponse(Mapping):
        pass

    class DescribeJobsRequest(Mapping):
        pass

    class DescribeJobsResponse(Mapping):
        pass

    class ListJobsRequest(Mapping):
        pass

    class ListJobsResponse(Mapping):
        pass

    class RegisterJobDefinitionRequest(Mapping):
        pass

    class RegisterJobDefinitionResponse(Mapping):
        pass

    class ParametersMap(object):
        pass

    class ContainerProperties(Mapping):
        pass

    class NodeProperties(Mapping):
        pass

    class RetryStrategy(Mapping):
        pass

    class JobTimeout(Mapping):
        pass

    class SubmitJobRequest(Mapping):
        pass

    class SubmitJobResponse(Mapping):
        pass

    class ArrayProperties(Mapping):
        pass

    class JobDependency(Mapping):
        pass

    class ContainerOverrides(Mapping):
        pass

    class NodeOverrides(Mapping):
        pass

    class TerminateJobRequest(Mapping):
        pass

    class TerminateJobResponse(Mapping):
        pass

    class UpdateComputeEnvironmentRequest(Mapping):
        pass

    class UpdateComputeEnvironmentResponse(Mapping):
        pass

    class ComputeResourceUpdate(Mapping):
        pass

    class UpdateJobQueueRequest(Mapping):
        pass

    class UpdateJobQueueResponse(Mapping):
        pass

    def cancel_job(self, reason: str, jobId: str) -> CancelJobResponse:
        pass

    def create_compute_environment(self, serviceRole: str, type: str, computeEnvironmentName: str, state: str=None, computeResources: ComputeResource=None) -> CreateComputeEnvironmentResponse:
        pass

    def create_job_queue(self, computeEnvironmentOrder: List[ComputeEnvironmentOrder], priority: int, jobQueueName: str, state: str=None) -> CreateJobQueueResponse:
        pass

    def delete_compute_environment(self, computeEnvironment: str) -> DeleteComputeEnvironmentResponse:
        pass

    def delete_job_queue(self, jobQueue: str) -> DeleteJobQueueResponse:
        pass

    def deregister_job_definition(self, jobDefinition: str) -> DeregisterJobDefinitionResponse:
        pass

    def describe_compute_environments(self, computeEnvironments: List[String]=None, maxResults: int=None, nextToken: str=None) -> DescribeComputeEnvironmentsResponse:
        pass

    def describe_job_definitions(self, jobDefinitions: List[String]=None, maxResults: int=None, jobDefinitionName: str=None, status: str=None, nextToken: str=None) -> DescribeJobDefinitionsResponse:
        pass

    def describe_job_queues(self, jobQueues: List[String]=None, maxResults: int=None, nextToken: str=None) -> DescribeJobQueuesResponse:
        pass

    def describe_jobs(self, jobs: List[String]) -> DescribeJobsResponse:
        pass

    def list_jobs(self, jobQueue: str=None, arrayJobId: str=None, multiNodeJobId: str=None, jobStatus: str=None, maxResults: int=None, nextToken: str=None) -> ListJobsResponse:
        pass

    def register_job_definition(self, type: str, jobDefinitionName: str, parameters: ParametersMap=None, containerProperties: ContainerProperties=None, nodeProperties: NodeProperties=None, retryStrategy: RetryStrategy=None, timeout: JobTimeout=None) -> RegisterJobDefinitionResponse:
        pass

    def submit_job(self, jobDefinition: str, jobQueue: str, jobName: str, arrayProperties: ArrayProperties=None, dependsOn: List[JobDependency]=None, parameters: ParametersMap=None, containerOverrides: ContainerOverrides=None, nodeOverrides: NodeOverrides=None, retryStrategy: RetryStrategy=None, timeout: JobTimeout=None) -> SubmitJobResponse:
        pass

    def terminate_job(self, reason: str, jobId: str) -> TerminateJobResponse:
        pass

    def update_compute_environment(self, computeEnvironment: str, state: str=None, computeResources: ComputeResourceUpdate=None, serviceRole: str=None) -> UpdateComputeEnvironmentResponse:
        pass

    def update_job_queue(self, jobQueue: str, state: str=None, priority: int=None, computeEnvironmentOrder: List[ComputeEnvironmentOrder]=None) -> UpdateJobQueueResponse:
        pass


class Budgets(BaseClient):
    class CreateBudgetRequest(Mapping):
        pass

    class CreateBudgetResponse(Mapping):
        pass

    class Budget(Mapping):
        pass

    class NotificationWithSubscribers(Mapping):
        pass

    class CreateNotificationRequest(Mapping):
        pass

    class CreateNotificationResponse(Mapping):
        pass

    class Notification(Mapping):
        pass

    class Subscriber(Mapping):
        pass

    class CreateSubscriberRequest(Mapping):
        pass

    class CreateSubscriberResponse(Mapping):
        pass

    class DeleteBudgetRequest(Mapping):
        pass

    class DeleteBudgetResponse(Mapping):
        pass

    class DeleteNotificationRequest(Mapping):
        pass

    class DeleteNotificationResponse(Mapping):
        pass

    class DeleteSubscriberRequest(Mapping):
        pass

    class DeleteSubscriberResponse(Mapping):
        pass

    class DescribeBudgetRequest(Mapping):
        pass

    class DescribeBudgetResponse(Mapping):
        pass

    class DescribeBudgetPerformanceHistoryRequest(Mapping):
        pass

    class DescribeBudgetPerformanceHistoryResponse(Mapping):
        pass

    class TimePeriod(Mapping):
        pass

    class DescribeBudgetsRequest(Mapping):
        pass

    class DescribeBudgetsResponse(Mapping):
        pass

    class DescribeNotificationsForBudgetRequest(Mapping):
        pass

    class DescribeNotificationsForBudgetResponse(Mapping):
        pass

    class DescribeSubscribersForNotificationRequest(Mapping):
        pass

    class DescribeSubscribersForNotificationResponse(Mapping):
        pass

    class UpdateBudgetRequest(Mapping):
        pass

    class UpdateBudgetResponse(Mapping):
        pass

    class UpdateNotificationRequest(Mapping):
        pass

    class UpdateNotificationResponse(Mapping):
        pass

    class UpdateSubscriberRequest(Mapping):
        pass

    class UpdateSubscriberResponse(Mapping):
        pass

    def create_budget(self, Budget: Budget, AccountId: str, NotificationsWithSubscribers: List[NotificationWithSubscribers]=None) -> CreateBudgetResponse:
        pass

    def create_notification(self, Subscribers: List[Subscriber], Notification: Notification, BudgetName: str, AccountId: str) -> CreateNotificationResponse:
        pass

    def create_subscriber(self, Subscriber: Subscriber, Notification: Notification, BudgetName: str, AccountId: str) -> CreateSubscriberResponse:
        pass

    def delete_budget(self, BudgetName: str, AccountId: str) -> DeleteBudgetResponse:
        pass

    def delete_notification(self, Notification: Notification, BudgetName: str, AccountId: str) -> DeleteNotificationResponse:
        pass

    def delete_subscriber(self, Subscriber: Subscriber, Notification: Notification, BudgetName: str, AccountId: str) -> DeleteSubscriberResponse:
        pass

    def describe_budget(self, BudgetName: str, AccountId: str) -> DescribeBudgetResponse:
        pass

    def describe_budget_performance_history(self, BudgetName: str, AccountId: str, TimePeriod: TimePeriod=None, MaxResults: int=None, NextToken: str=None) -> DescribeBudgetPerformanceHistoryResponse:
        pass

    def describe_budgets(self, AccountId: str, MaxResults: int=None, NextToken: str=None) -> DescribeBudgetsResponse:
        pass

    def describe_notifications_for_budget(self, BudgetName: str, AccountId: str, MaxResults: int=None, NextToken: str=None) -> DescribeNotificationsForBudgetResponse:
        pass

    def describe_subscribers_for_notification(self, Notification: Notification, BudgetName: str, AccountId: str, MaxResults: int=None, NextToken: str=None) -> DescribeSubscribersForNotificationResponse:
        pass

    def update_budget(self, NewBudget: Budget, AccountId: str) -> UpdateBudgetResponse:
        pass

    def update_notification(self, NewNotification: Notification, OldNotification: Notification, BudgetName: str, AccountId: str) -> UpdateNotificationResponse:
        pass

    def update_subscriber(self, NewSubscriber: Subscriber, OldSubscriber: Subscriber, Notification: Notification, BudgetName: str, AccountId: str) -> UpdateSubscriberResponse:
        pass


class CostExplorer(BaseClient):
    class GetCostAndUsageRequest(Mapping):
        pass

    class GetCostAndUsageResponse(Mapping):
        pass

    class DateInterval(Mapping):
        pass

    class Expression(Mapping):
        pass

    class MetricName(object):
        pass

    class GroupDefinition(Mapping):
        pass

    class GetCostForecastRequest(Mapping):
        pass

    class GetCostForecastResponse(Mapping):
        pass

    class GetDimensionValuesRequest(Mapping):
        pass

    class GetDimensionValuesResponse(Mapping):
        pass

    class GetReservationCoverageRequest(Mapping):
        pass

    class GetReservationCoverageResponse(Mapping):
        pass

    class GetReservationPurchaseRecommendationRequest(Mapping):
        pass

    class GetReservationPurchaseRecommendationResponse(Mapping):
        pass

    class ServiceSpecification(Mapping):
        pass

    class GetReservationUtilizationRequest(Mapping):
        pass

    class GetReservationUtilizationResponse(Mapping):
        pass

    class GetTagsRequest(Mapping):
        pass

    class GetTagsResponse(Mapping):
        pass

    def get_cost_and_usage(self, TimePeriod: DateInterval=None, Granularity: str=None, Filter: Expression=None, Metrics: List[MetricName]=None, GroupBy: List[GroupDefinition]=None, NextPageToken: str=None) -> GetCostAndUsageResponse:
        pass

    def get_cost_forecast(self, Granularity: str, Metric: str, TimePeriod: DateInterval, Filter: Expression=None, PredictionIntervalLevel: int=None) -> GetCostForecastResponse:
        pass

    def get_dimension_values(self, Dimension: str, TimePeriod: DateInterval, SearchString: str=None, Context: str=None, NextPageToken: str=None) -> GetDimensionValuesResponse:
        pass

    def get_reservation_coverage(self, TimePeriod: DateInterval, GroupBy: List[GroupDefinition]=None, Granularity: str=None, Filter: Expression=None, Metrics: List[MetricName]=None, NextPageToken: str=None) -> GetReservationCoverageResponse:
        pass

    def get_reservation_purchase_recommendation(self, Service: str, AccountId: str=None, AccountScope: str=None, LookbackPeriodInDays: str=None, TermInYears: str=None, PaymentOption: str=None, ServiceSpecification: ServiceSpecification=None, PageSize: int=None, NextPageToken: str=None) -> GetReservationPurchaseRecommendationResponse:
        pass

    def get_reservation_utilization(self, TimePeriod: DateInterval, GroupBy: List[GroupDefinition]=None, Granularity: str=None, Filter: Expression=None, NextPageToken: str=None) -> GetReservationUtilizationResponse:
        pass

    def get_tags(self, TimePeriod: DateInterval, SearchString: str=None, TagKey: str=None, NextPageToken: str=None) -> GetTagsResponse:
        pass


class Chime(BaseClient):
    class BatchSuspendUserRequest(Mapping):
        pass

    class BatchSuspendUserResponse(Mapping):
        pass

    class NonEmptyString(object):
        pass

    class BatchUnsuspendUserRequest(Mapping):
        pass

    class BatchUnsuspendUserResponse(Mapping):
        pass

    class BatchUpdateUserRequest(Mapping):
        pass

    class BatchUpdateUserResponse(Mapping):
        pass

    class UpdateUserRequestItem(Mapping):
        pass

    class CreateAccountRequest(Mapping):
        pass

    class CreateAccountResponse(Mapping):
        pass

    class DeleteAccountRequest(Mapping):
        pass

    class DeleteAccountResponse(Mapping):
        pass

    class GetAccountRequest(Mapping):
        pass

    class GetAccountResponse(Mapping):
        pass

    class GetAccountSettingsRequest(Mapping):
        pass

    class GetAccountSettingsResponse(Mapping):
        pass

    class GetUserRequest(Mapping):
        pass

    class GetUserResponse(Mapping):
        pass

    class InviteUsersRequest(Mapping):
        pass

    class InviteUsersResponse(Mapping):
        pass

    class EmailAddress(object):
        pass

    class ListAccountsRequest(Mapping):
        pass

    class ListAccountsResponse(Mapping):
        pass

    class ListUsersRequest(Mapping):
        pass

    class ListUsersResponse(Mapping):
        pass

    class LogoutUserRequest(Mapping):
        pass

    class LogoutUserResponse(Mapping):
        pass

    class ResetPersonalPINRequest(Mapping):
        pass

    class ResetPersonalPINResponse(Mapping):
        pass

    class UpdateAccountRequest(Mapping):
        pass

    class UpdateAccountResponse(Mapping):
        pass

    class UpdateAccountSettingsRequest(Mapping):
        pass

    class UpdateAccountSettingsResponse(Mapping):
        pass

    class AccountSettings(Mapping):
        pass

    class UpdateUserRequest(Mapping):
        pass

    class UpdateUserResponse(Mapping):
        pass

    def batch_suspend_user(self, UserIdList: List[NonEmptyString], AccountId: str) -> BatchSuspendUserResponse:
        pass

    def batch_unsuspend_user(self, UserIdList: List[NonEmptyString], AccountId: str) -> BatchUnsuspendUserResponse:
        pass

    def batch_update_user(self, UpdateUserRequestItems: List[UpdateUserRequestItem], AccountId: str) -> BatchUpdateUserResponse:
        pass

    def create_account(self, Name: str) -> CreateAccountResponse:
        pass

    def delete_account(self, AccountId: str) -> DeleteAccountResponse:
        pass

    def get_account(self, AccountId: str) -> GetAccountResponse:
        pass

    def get_account_settings(self, AccountId: str) -> GetAccountSettingsResponse:
        pass

    def get_user(self, UserId: str, AccountId: str) -> GetUserResponse:
        pass

    def invite_users(self, UserEmailList: List[EmailAddress], AccountId: str) -> InviteUsersResponse:
        pass

    def list_accounts(self, Name: str=None, UserEmail: str=None, NextToken: str=None, MaxResults: int=None) -> ListAccountsResponse:
        pass

    def list_users(self, AccountId: str, UserEmail: str=None, MaxResults: int=None, NextToken: str=None) -> ListUsersResponse:
        pass

    def logout_user(self, UserId: str, AccountId: str) -> LogoutUserResponse:
        pass

    def reset_personal_pin(self, UserId: str, AccountId: str) -> ResetPersonalPINResponse:
        pass

    def update_account(self, AccountId: str, Name: str=None) -> UpdateAccountResponse:
        pass

    def update_account_settings(self, AccountSettings: AccountSettings, AccountId: str) -> UpdateAccountSettingsResponse:
        pass

    def update_user(self, UserId: str, AccountId: str, LicenseType: str=None) -> UpdateUserResponse:
        pass


class Cloud9(BaseClient):
    class CreateEnvironmentEC2Request(Mapping):
        pass

    class CreateEnvironmentEC2Result(Mapping):
        pass

    class CreateEnvironmentMembershipRequest(Mapping):
        pass

    class CreateEnvironmentMembershipResult(Mapping):
        pass

    class DeleteEnvironmentRequest(Mapping):
        pass

    class DeleteEnvironmentResult(Mapping):
        pass

    class DeleteEnvironmentMembershipRequest(Mapping):
        pass

    class DeleteEnvironmentMembershipResult(Mapping):
        pass

    class DescribeEnvironmentMembershipsRequest(Mapping):
        pass

    class DescribeEnvironmentMembershipsResult(Mapping):
        pass

    class Permissions(object):
        pass

    class DescribeEnvironmentStatusRequest(Mapping):
        pass

    class DescribeEnvironmentStatusResult(Mapping):
        pass

    class DescribeEnvironmentsRequest(Mapping):
        pass

    class DescribeEnvironmentsResult(Mapping):
        pass

    class EnvironmentId(object):
        pass

    class ListEnvironmentsRequest(Mapping):
        pass

    class ListEnvironmentsResult(Mapping):
        pass

    class UpdateEnvironmentRequest(Mapping):
        pass

    class UpdateEnvironmentResult(Mapping):
        pass

    class UpdateEnvironmentMembershipRequest(Mapping):
        pass

    class UpdateEnvironmentMembershipResult(Mapping):
        pass

    def create_environment_ec2(self, instanceType: str, name: str, description: str=None, clientRequestToken: str=None, subnetId: str=None, automaticStopTimeMinutes: int=None, ownerArn: str=None) -> CreateEnvironmentEC2Result:
        pass

    def create_environment_membership(self, permissions: str, userArn: str, environmentId: str) -> CreateEnvironmentMembershipResult:
        pass

    def delete_environment(self, environmentId: str) -> DeleteEnvironmentResult:
        pass

    def delete_environment_membership(self, userArn: str, environmentId: str) -> DeleteEnvironmentMembershipResult:
        pass

    def describe_environment_memberships(self, userArn: str=None, environmentId: str=None, permissions: List[Permissions]=None, nextToken: str=None, maxResults: int=None) -> DescribeEnvironmentMembershipsResult:
        pass

    def describe_environment_status(self, environmentId: str) -> DescribeEnvironmentStatusResult:
        pass

    def describe_environments(self, environmentIds: List[EnvironmentId]) -> DescribeEnvironmentsResult:
        pass

    def list_environments(self, nextToken: str=None, maxResults: int=None) -> ListEnvironmentsResult:
        pass

    def update_environment(self, environmentId: str, name: str=None, description: str=None) -> UpdateEnvironmentResult:
        pass

    def update_environment_membership(self, permissions: str, userArn: str, environmentId: str) -> UpdateEnvironmentMembershipResult:
        pass


class CloudDirectory(BaseClient):
    class AddFacetToObjectRequest(Mapping):
        pass

    class AddFacetToObjectResponse(Mapping):
        pass

    class SchemaFacet(Mapping):
        pass

    class AttributeKeyAndValue(Mapping):
        pass

    class ObjectReference(Mapping):
        pass

    class ApplySchemaRequest(Mapping):
        pass

    class ApplySchemaResponse(Mapping):
        pass

    class AttachObjectRequest(Mapping):
        pass

    class AttachObjectResponse(Mapping):
        pass

    class AttachPolicyRequest(Mapping):
        pass

    class AttachPolicyResponse(Mapping):
        pass

    class AttachToIndexRequest(Mapping):
        pass

    class AttachToIndexResponse(Mapping):
        pass

    class AttachTypedLinkRequest(Mapping):
        pass

    class AttachTypedLinkResponse(Mapping):
        pass

    class TypedLinkSchemaAndFacetName(Mapping):
        pass

    class AttributeNameAndValue(Mapping):
        pass

    class BatchReadRequest(Mapping):
        pass

    class BatchReadResponse(Mapping):
        pass

    class BatchReadOperation(Mapping):
        pass

    class BatchWriteRequest(Mapping):
        pass

    class BatchWriteResponse(Mapping):
        pass

    class BatchWriteOperation(Mapping):
        pass

    class CreateDirectoryRequest(Mapping):
        pass

    class CreateDirectoryResponse(Mapping):
        pass

    class CreateFacetRequest(Mapping):
        pass

    class CreateFacetResponse(Mapping):
        pass

    class FacetAttribute(Mapping):
        pass

    class CreateIndexRequest(Mapping):
        pass

    class CreateIndexResponse(Mapping):
        pass

    class AttributeKey(Mapping):
        pass

    class Bool(object):
        pass

    class CreateObjectRequest(Mapping):
        pass

    class CreateObjectResponse(Mapping):
        pass

    class CreateSchemaRequest(Mapping):
        pass

    class CreateSchemaResponse(Mapping):
        pass

    class CreateTypedLinkFacetRequest(Mapping):
        pass

    class CreateTypedLinkFacetResponse(Mapping):
        pass

    class TypedLinkFacet(Mapping):
        pass

    class DeleteDirectoryRequest(Mapping):
        pass

    class DeleteDirectoryResponse(Mapping):
        pass

    class DeleteFacetRequest(Mapping):
        pass

    class DeleteFacetResponse(Mapping):
        pass

    class DeleteObjectRequest(Mapping):
        pass

    class DeleteObjectResponse(Mapping):
        pass

    class DeleteSchemaRequest(Mapping):
        pass

    class DeleteSchemaResponse(Mapping):
        pass

    class DeleteTypedLinkFacetRequest(Mapping):
        pass

    class DeleteTypedLinkFacetResponse(Mapping):
        pass

    class DetachFromIndexRequest(Mapping):
        pass

    class DetachFromIndexResponse(Mapping):
        pass

    class DetachObjectRequest(Mapping):
        pass

    class DetachObjectResponse(Mapping):
        pass

    class DetachPolicyRequest(Mapping):
        pass

    class DetachPolicyResponse(Mapping):
        pass

    class DetachTypedLinkRequest(Mapping):
        pass

    class TypedLinkSpecifier(Mapping):
        pass

    class DisableDirectoryRequest(Mapping):
        pass

    class DisableDirectoryResponse(Mapping):
        pass

    class EnableDirectoryRequest(Mapping):
        pass

    class EnableDirectoryResponse(Mapping):
        pass

    class GetAppliedSchemaVersionRequest(Mapping):
        pass

    class GetAppliedSchemaVersionResponse(Mapping):
        pass

    class GetDirectoryRequest(Mapping):
        pass

    class GetDirectoryResponse(Mapping):
        pass

    class GetFacetRequest(Mapping):
        pass

    class GetFacetResponse(Mapping):
        pass

    class GetLinkAttributesRequest(Mapping):
        pass

    class GetLinkAttributesResponse(Mapping):
        pass

    class AttributeName(object):
        pass

    class GetObjectAttributesRequest(Mapping):
        pass

    class GetObjectAttributesResponse(Mapping):
        pass

    class GetObjectInformationRequest(Mapping):
        pass

    class GetObjectInformationResponse(Mapping):
        pass

    class GetSchemaAsJsonRequest(Mapping):
        pass

    class GetSchemaAsJsonResponse(Mapping):
        pass

    class GetTypedLinkFacetInformationRequest(Mapping):
        pass

    class GetTypedLinkFacetInformationResponse(Mapping):
        pass

    class ListAppliedSchemaArnsRequest(Mapping):
        pass

    class ListAppliedSchemaArnsResponse(Mapping):
        pass

    class ListAttachedIndicesRequest(Mapping):
        pass

    class ListAttachedIndicesResponse(Mapping):
        pass

    class ListDevelopmentSchemaArnsRequest(Mapping):
        pass

    class ListDevelopmentSchemaArnsResponse(Mapping):
        pass

    class ListDirectoriesRequest(Mapping):
        pass

    class ListDirectoriesResponse(Mapping):
        pass

    class ListFacetAttributesRequest(Mapping):
        pass

    class ListFacetAttributesResponse(Mapping):
        pass

    class ListFacetNamesRequest(Mapping):
        pass

    class ListFacetNamesResponse(Mapping):
        pass

    class ListIncomingTypedLinksRequest(Mapping):
        pass

    class ListIncomingTypedLinksResponse(Mapping):
        pass

    class TypedLinkAttributeRange(Mapping):
        pass

    class ListIndexRequest(Mapping):
        pass

    class ListIndexResponse(Mapping):
        pass

    class ObjectAttributeRange(Mapping):
        pass

    class ListManagedSchemaArnsRequest(Mapping):
        pass

    class ListManagedSchemaArnsResponse(Mapping):
        pass

    class ListObjectAttributesRequest(Mapping):
        pass

    class ListObjectAttributesResponse(Mapping):
        pass

    class ListObjectChildrenRequest(Mapping):
        pass

    class ListObjectChildrenResponse(Mapping):
        pass

    class ListObjectParentPathsRequest(Mapping):
        pass

    class ListObjectParentPathsResponse(Mapping):
        pass

    class ListObjectParentsRequest(Mapping):
        pass

    class ListObjectParentsResponse(Mapping):
        pass

    class ListObjectPoliciesRequest(Mapping):
        pass

    class ListObjectPoliciesResponse(Mapping):
        pass

    class ListOutgoingTypedLinksRequest(Mapping):
        pass

    class ListOutgoingTypedLinksResponse(Mapping):
        pass

    class ListPolicyAttachmentsRequest(Mapping):
        pass

    class ListPolicyAttachmentsResponse(Mapping):
        pass

    class ListPublishedSchemaArnsRequest(Mapping):
        pass

    class ListPublishedSchemaArnsResponse(Mapping):
        pass

    class ListTagsForResourceRequest(Mapping):
        pass

    class ListTagsForResourceResponse(Mapping):
        pass

    class ListTypedLinkFacetAttributesRequest(Mapping):
        pass

    class ListTypedLinkFacetAttributesResponse(Mapping):
        pass

    class ListTypedLinkFacetNamesRequest(Mapping):
        pass

    class ListTypedLinkFacetNamesResponse(Mapping):
        pass

    class LookupPolicyRequest(Mapping):
        pass

    class LookupPolicyResponse(Mapping):
        pass

    class PublishSchemaRequest(Mapping):
        pass

    class PublishSchemaResponse(Mapping):
        pass

    class PutSchemaFromJsonRequest(Mapping):
        pass

    class PutSchemaFromJsonResponse(Mapping):
        pass

    class RemoveFacetFromObjectRequest(Mapping):
        pass

    class RemoveFacetFromObjectResponse(Mapping):
        pass

    class TagResourceRequest(Mapping):
        pass

    class TagResourceResponse(Mapping):
        pass

    class Tag(Mapping):
        pass

    class UntagResourceRequest(Mapping):
        pass

    class UntagResourceResponse(Mapping):
        pass

    class TagKey(object):
        pass

    class UpdateFacetRequest(Mapping):
        pass

    class UpdateFacetResponse(Mapping):
        pass

    class FacetAttributeUpdate(Mapping):
        pass

    class UpdateLinkAttributesRequest(Mapping):
        pass

    class UpdateLinkAttributesResponse(Mapping):
        pass

    class LinkAttributeUpdate(Mapping):
        pass

    class UpdateObjectAttributesRequest(Mapping):
        pass

    class UpdateObjectAttributesResponse(Mapping):
        pass

    class ObjectAttributeUpdate(Mapping):
        pass

    class UpdateSchemaRequest(Mapping):
        pass

    class UpdateSchemaResponse(Mapping):
        pass

    class UpdateTypedLinkFacetRequest(Mapping):
        pass

    class UpdateTypedLinkFacetResponse(Mapping):
        pass

    class TypedLinkFacetAttributeUpdate(Mapping):
        pass

    class UpgradeAppliedSchemaRequest(Mapping):
        pass

    class UpgradeAppliedSchemaResponse(Mapping):
        pass

    class UpgradePublishedSchemaRequest(Mapping):
        pass

    class UpgradePublishedSchemaResponse(Mapping):
        pass

    def add_facet_to_object(self, ObjectReference: ObjectReference, SchemaFacet: SchemaFacet, DirectoryArn: str, ObjectAttributeList: List[AttributeKeyAndValue]=None) -> AddFacetToObjectResponse:
        pass

    def apply_schema(self, DirectoryArn: str, PublishedSchemaArn: str) -> ApplySchemaResponse:
        pass

    def attach_object(self, LinkName: str, ChildReference: ObjectReference, ParentReference: ObjectReference, DirectoryArn: str) -> AttachObjectResponse:
        pass

    def attach_policy(self, ObjectReference: ObjectReference, PolicyReference: ObjectReference, DirectoryArn: str) -> AttachPolicyResponse:
        pass

    def attach_to_index(self, TargetReference: ObjectReference, IndexReference: ObjectReference, DirectoryArn: str) -> AttachToIndexResponse:
        pass

    def attach_typed_link(self, Attributes: List[AttributeNameAndValue], TypedLinkFacet: TypedLinkSchemaAndFacetName, TargetObjectReference: ObjectReference, SourceObjectReference: ObjectReference, DirectoryArn: str) -> AttachTypedLinkResponse:
        pass

    def batch_read(self, Operations: List[BatchReadOperation], DirectoryArn: str, ConsistencyLevel: str=None) -> BatchReadResponse:
        pass

    def batch_write(self, Operations: List[BatchWriteOperation], DirectoryArn: str) -> BatchWriteResponse:
        pass

    def create_directory(self, SchemaArn: str, Name: str) -> CreateDirectoryResponse:
        pass

    def create_facet(self, Name: str, SchemaArn: str, Attributes: List[FacetAttribute]=None, ObjectType: str=None, FacetStyle: str=None) -> CreateFacetResponse:
        pass

    def create_index(self, IsUnique: Bool, OrderedIndexedAttributeList: List[AttributeKey], DirectoryArn: str, ParentReference: ObjectReference=None, LinkName: str=None) -> CreateIndexResponse:
        pass

    def create_object(self, SchemaFacets: List[SchemaFacet], DirectoryArn: str, ObjectAttributeList: List[AttributeKeyAndValue]=None, ParentReference: ObjectReference=None, LinkName: str=None) -> CreateObjectResponse:
        pass

    def create_schema(self, Name: str) -> CreateSchemaResponse:
        pass

    def create_typed_link_facet(self, Facet: TypedLinkFacet, SchemaArn: str) -> CreateTypedLinkFacetResponse:
        pass

    def delete_directory(self, DirectoryArn: str) -> DeleteDirectoryResponse:
        pass

    def delete_facet(self, Name: str, SchemaArn: str) -> DeleteFacetResponse:
        pass

    def delete_object(self, ObjectReference: ObjectReference, DirectoryArn: str) -> DeleteObjectResponse:
        pass

    def delete_schema(self, SchemaArn: str) -> DeleteSchemaResponse:
        pass

    def delete_typed_link_facet(self, Name: str, SchemaArn: str) -> DeleteTypedLinkFacetResponse:
        pass

    def detach_from_index(self, TargetReference: ObjectReference, IndexReference: ObjectReference, DirectoryArn: str) -> DetachFromIndexResponse:
        pass

    def detach_object(self, LinkName: str, ParentReference: ObjectReference, DirectoryArn: str) -> DetachObjectResponse:
        pass

    def detach_policy(self, ObjectReference: ObjectReference, PolicyReference: ObjectReference, DirectoryArn: str) -> DetachPolicyResponse:
        pass

    def detach_typed_link(self, TypedLinkSpecifier: TypedLinkSpecifier, DirectoryArn: str):
        pass

    def disable_directory(self, DirectoryArn: str) -> DisableDirectoryResponse:
        pass

    def enable_directory(self, DirectoryArn: str) -> EnableDirectoryResponse:
        pass

    def get_applied_schema_version(self, SchemaArn: str) -> GetAppliedSchemaVersionResponse:
        pass

    def get_directory(self, DirectoryArn: str) -> GetDirectoryResponse:
        pass

    def get_facet(self, Name: str, SchemaArn: str) -> GetFacetResponse:
        pass

    def get_link_attributes(self, AttributeNames: List[AttributeName], TypedLinkSpecifier: TypedLinkSpecifier, DirectoryArn: str, ConsistencyLevel: str=None) -> GetLinkAttributesResponse:
        pass

    def get_object_attributes(self, AttributeNames: List[AttributeName], SchemaFacet: SchemaFacet, ObjectReference: ObjectReference, DirectoryArn: str, ConsistencyLevel: str=None) -> GetObjectAttributesResponse:
        pass

    def get_object_information(self, ObjectReference: ObjectReference, DirectoryArn: str, ConsistencyLevel: str=None) -> GetObjectInformationResponse:
        pass

    def get_schema_as_json(self, SchemaArn: str) -> GetSchemaAsJsonResponse:
        pass

    def get_typed_link_facet_information(self, Name: str, SchemaArn: str) -> GetTypedLinkFacetInformationResponse:
        pass

    def list_applied_schema_arns(self, DirectoryArn: str, SchemaArn: str=None, NextToken: str=None, MaxResults: int=None) -> ListAppliedSchemaArnsResponse:
        pass

    def list_attached_indices(self, TargetReference: ObjectReference, DirectoryArn: str, NextToken: str=None, MaxResults: int=None, ConsistencyLevel: str=None) -> ListAttachedIndicesResponse:
        pass

    def list_development_schema_arns(self, NextToken: str=None, MaxResults: int=None) -> ListDevelopmentSchemaArnsResponse:
        pass

    def list_directories(self, NextToken: str=None, MaxResults: int=None, state: str=None) -> ListDirectoriesResponse:
        pass

    def list_facet_attributes(self, Name: str, SchemaArn: str, NextToken: str=None, MaxResults: int=None) -> ListFacetAttributesResponse:
        pass

    def list_facet_names(self, SchemaArn: str, NextToken: str=None, MaxResults: int=None) -> ListFacetNamesResponse:
        pass

    def list_incoming_typed_links(self, ObjectReference: ObjectReference, DirectoryArn: str, FilterAttributeRanges: List[TypedLinkAttributeRange]=None, FilterTypedLink: TypedLinkSchemaAndFacetName=None, NextToken: str=None, MaxResults: int=None, ConsistencyLevel: str=None) -> ListIncomingTypedLinksResponse:
        pass

    def list_index(self, IndexReference: ObjectReference, DirectoryArn: str, RangesOnIndexedValues: List[ObjectAttributeRange]=None, MaxResults: int=None, NextToken: str=None, ConsistencyLevel: str=None) -> ListIndexResponse:
        pass

    def list_managed_schema_arns(self, SchemaArn: str=None, NextToken: str=None, MaxResults: int=None) -> ListManagedSchemaArnsResponse:
        pass

    def list_object_attributes(self, ObjectReference: ObjectReference, DirectoryArn: str, NextToken: str=None, MaxResults: int=None, ConsistencyLevel: str=None, FacetFilter: SchemaFacet=None) -> ListObjectAttributesResponse:
        pass

    def list_object_children(self, ObjectReference: ObjectReference, DirectoryArn: str, NextToken: str=None, MaxResults: int=None, ConsistencyLevel: str=None) -> ListObjectChildrenResponse:
        pass

    def list_object_parent_paths(self, ObjectReference: ObjectReference, DirectoryArn: str, NextToken: str=None, MaxResults: int=None) -> ListObjectParentPathsResponse:
        pass

    def list_object_parents(self, ObjectReference: ObjectReference, DirectoryArn: str, NextToken: str=None, MaxResults: int=None, ConsistencyLevel: str=None, IncludeAllLinksToEachParent: Bool=None) -> ListObjectParentsResponse:
        pass

    def list_object_policies(self, ObjectReference: ObjectReference, DirectoryArn: str, NextToken: str=None, MaxResults: int=None, ConsistencyLevel: str=None) -> ListObjectPoliciesResponse:
        pass

    def list_outgoing_typed_links(self, ObjectReference: ObjectReference, DirectoryArn: str, FilterAttributeRanges: List[TypedLinkAttributeRange]=None, FilterTypedLink: TypedLinkSchemaAndFacetName=None, NextToken: str=None, MaxResults: int=None, ConsistencyLevel: str=None) -> ListOutgoingTypedLinksResponse:
        pass

    def list_policy_attachments(self, PolicyReference: ObjectReference, DirectoryArn: str, NextToken: str=None, MaxResults: int=None, ConsistencyLevel: str=None) -> ListPolicyAttachmentsResponse:
        pass

    def list_published_schema_arns(self, SchemaArn: str=None, NextToken: str=None, MaxResults: int=None) -> ListPublishedSchemaArnsResponse:
        pass

    def list_tags_for_resource(self, ResourceArn: str, NextToken: str=None, MaxResults: int=None) -> ListTagsForResourceResponse:
        pass

    def list_typed_link_facet_attributes(self, Name: str, SchemaArn: str, NextToken: str=None, MaxResults: int=None) -> ListTypedLinkFacetAttributesResponse:
        pass

    def list_typed_link_facet_names(self, SchemaArn: str, NextToken: str=None, MaxResults: int=None) -> ListTypedLinkFacetNamesResponse:
        pass

    def lookup_policy(self, ObjectReference: ObjectReference, DirectoryArn: str, NextToken: str=None, MaxResults: int=None) -> LookupPolicyResponse:
        pass

    def publish_schema(self, Version: str, DevelopmentSchemaArn: str, MinorVersion: str=None, Name: str=None) -> PublishSchemaResponse:
        pass

    def put_schema_from_json(self, Document: str, SchemaArn: str) -> PutSchemaFromJsonResponse:
        pass

    def remove_facet_from_object(self, ObjectReference: ObjectReference, SchemaFacet: SchemaFacet, DirectoryArn: str) -> RemoveFacetFromObjectResponse:
        pass

    def tag_resource(self, Tags: List[Tag], ResourceArn: str) -> TagResourceResponse:
        pass

    def untag_resource(self, TagKeys: List[TagKey], ResourceArn: str) -> UntagResourceResponse:
        pass

    def update_facet(self, Name: str, SchemaArn: str, AttributeUpdates: List[FacetAttributeUpdate]=None, ObjectType: str=None) -> UpdateFacetResponse:
        pass

    def update_link_attributes(self, AttributeUpdates: List[LinkAttributeUpdate], TypedLinkSpecifier: TypedLinkSpecifier, DirectoryArn: str) -> UpdateLinkAttributesResponse:
        pass

    def update_object_attributes(self, AttributeUpdates: List[ObjectAttributeUpdate], ObjectReference: ObjectReference, DirectoryArn: str) -> UpdateObjectAttributesResponse:
        pass

    def update_schema(self, Name: str, SchemaArn: str) -> UpdateSchemaResponse:
        pass

    def update_typed_link_facet(self, IdentityAttributeOrder: List[AttributeName], AttributeUpdates: List[TypedLinkFacetAttributeUpdate], Name: str, SchemaArn: str) -> UpdateTypedLinkFacetResponse:
        pass

    def upgrade_applied_schema(self, DirectoryArn: str, PublishedSchemaArn: str, DryRun: Bool=None) -> UpgradeAppliedSchemaResponse:
        pass

    def upgrade_published_schema(self, MinorVersion: str, PublishedSchemaArn: str, DevelopmentSchemaArn: str, DryRun: Bool=None) -> UpgradePublishedSchemaResponse:
        pass


class CloudFormation(BaseClient):
    class CancelUpdateStackInput(Mapping):
        pass

    class ContinueUpdateRollbackInput(Mapping):
        pass

    class ContinueUpdateRollbackOutput(Mapping):
        pass

    class ResourceToSkip(object):
        pass

    class CreateChangeSetInput(Mapping):
        pass

    class CreateChangeSetOutput(Mapping):
        pass

    class UsePreviousTemplate(object):
        pass

    class Parameter(Mapping):
        pass

    class Capability(object):
        pass

    class ResourceType(object):
        pass

    class RollbackConfiguration(Mapping):
        pass

    class NotificationARN(object):
        pass

    class Tag(Mapping):
        pass

    class CreateStackInput(Mapping):
        pass

    class CreateStackOutput(Mapping):
        pass

    class DisableRollback(object):
        pass

    class EnableTerminationProtection(object):
        pass

    class CreateStackInstancesInput(Mapping):
        pass

    class CreateStackInstancesOutput(Mapping):
        pass

    class Account(object):
        pass

    class Region(object):
        pass

    class StackSetOperationPreferences(Mapping):
        pass

    class CreateStackSetInput(Mapping):
        pass

    class CreateStackSetOutput(Mapping):
        pass

    class DeleteChangeSetInput(Mapping):
        pass

    class DeleteChangeSetOutput(Mapping):
        pass

    class DeleteStackInput(Mapping):
        pass

    class LogicalResourceId(object):
        pass

    class DeleteStackInstancesInput(Mapping):
        pass

    class DeleteStackInstancesOutput(Mapping):
        pass

    class RetainStacks(object):
        pass

    class DeleteStackSetInput(Mapping):
        pass

    class DeleteStackSetOutput(Mapping):
        pass

    class DescribeAccountLimitsInput(Mapping):
        pass

    class DescribeAccountLimitsOutput(Mapping):
        pass

    class DescribeChangeSetInput(Mapping):
        pass

    class DescribeChangeSetOutput(Mapping):
        pass

    class DescribeStackDriftDetectionStatusInput(Mapping):
        pass

    class DescribeStackDriftDetectionStatusOutput(Mapping):
        pass

    class DescribeStackEventsInput(Mapping):
        pass

    class DescribeStackEventsOutput(Mapping):
        pass

    class DescribeStackInstanceInput(Mapping):
        pass

    class DescribeStackInstanceOutput(Mapping):
        pass

    class DescribeStackResourceInput(Mapping):
        pass

    class DescribeStackResourceOutput(Mapping):
        pass

    class DescribeStackResourceDriftsInput(Mapping):
        pass

    class DescribeStackResourceDriftsOutput(Mapping):
        pass

    class StackResourceDriftStatus(object):
        pass

    class DescribeStackResourcesInput(Mapping):
        pass

    class DescribeStackResourcesOutput(Mapping):
        pass

    class DescribeStackSetInput(Mapping):
        pass

    class DescribeStackSetOutput(Mapping):
        pass

    class DescribeStackSetOperationInput(Mapping):
        pass

    class DescribeStackSetOperationOutput(Mapping):
        pass

    class DescribeStacksInput(Mapping):
        pass

    class DescribeStacksOutput(Mapping):
        pass

    class DetectStackDriftInput(Mapping):
        pass

    class DetectStackDriftOutput(Mapping):
        pass

    class DetectStackResourceDriftInput(Mapping):
        pass

    class DetectStackResourceDriftOutput(Mapping):
        pass

    class EstimateTemplateCostInput(Mapping):
        pass

    class EstimateTemplateCostOutput(Mapping):
        pass

    class ExecuteChangeSetInput(Mapping):
        pass

    class ExecuteChangeSetOutput(Mapping):
        pass

    class GetStackPolicyInput(Mapping):
        pass

    class GetStackPolicyOutput(Mapping):
        pass

    class GetTemplateInput(Mapping):
        pass

    class GetTemplateOutput(Mapping):
        pass

    class GetTemplateSummaryInput(Mapping):
        pass

    class GetTemplateSummaryOutput(Mapping):
        pass

    class ListChangeSetsInput(Mapping):
        pass

    class ListChangeSetsOutput(Mapping):
        pass

    class ListExportsInput(Mapping):
        pass

    class ListExportsOutput(Mapping):
        pass

    class ListImportsInput(Mapping):
        pass

    class ListImportsOutput(Mapping):
        pass

    class ListStackInstancesInput(Mapping):
        pass

    class ListStackInstancesOutput(Mapping):
        pass

    class ListStackResourcesInput(Mapping):
        pass

    class ListStackResourcesOutput(Mapping):
        pass

    class ListStackSetOperationResultsInput(Mapping):
        pass

    class ListStackSetOperationResultsOutput(Mapping):
        pass

    class ListStackSetOperationsInput(Mapping):
        pass

    class ListStackSetOperationsOutput(Mapping):
        pass

    class ListStackSetsInput(Mapping):
        pass

    class ListStackSetsOutput(Mapping):
        pass

    class ListStacksInput(Mapping):
        pass

    class ListStacksOutput(Mapping):
        pass

    class StackStatus(object):
        pass

    class SetStackPolicyInput(Mapping):
        pass

    class SignalResourceInput(Mapping):
        pass

    class StopStackSetOperationInput(Mapping):
        pass

    class StopStackSetOperationOutput(Mapping):
        pass

    class UpdateStackInput(Mapping):
        pass

    class UpdateStackOutput(Mapping):
        pass

    class UpdateStackInstancesInput(Mapping):
        pass

    class UpdateStackInstancesOutput(Mapping):
        pass

    class UpdateStackSetInput(Mapping):
        pass

    class UpdateStackSetOutput(Mapping):
        pass

    class UpdateTerminationProtectionInput(Mapping):
        pass

    class UpdateTerminationProtectionOutput(Mapping):
        pass

    class ValidateTemplateInput(Mapping):
        pass

    class ValidateTemplateOutput(Mapping):
        pass

    def cancel_update_stack(self, StackName: str, ClientRequestToken: str=None):
        pass

    def continue_update_rollback(self, StackName: str, RoleARN: str=None, ResourcesToSkip: List[ResourceToSkip]=None, ClientRequestToken: str=None) -> ContinueUpdateRollbackOutput:
        pass

    def create_change_set(self, ChangeSetName: str, StackName: str, TemplateBody: str=None, TemplateURL: str=None, UsePreviousTemplate: UsePreviousTemplate=None, Parameters: List[Parameter]=None, Capabilities: List[Capability]=None, ResourceTypes: List[ResourceType]=None, RoleARN: str=None, RollbackConfiguration: RollbackConfiguration=None, NotificationARNs: List[NotificationARN]=None, Tags: List[Tag]=None, ClientToken: str=None, Description: str=None, ChangeSetType: str=None) -> CreateChangeSetOutput:
        pass

    def create_stack(self, StackName: str, TemplateBody: str=None, TemplateURL: str=None, Parameters: List[Parameter]=None, DisableRollback: DisableRollback=None, RollbackConfiguration: RollbackConfiguration=None, TimeoutInMinutes: int=None, NotificationARNs: List[NotificationARN]=None, Capabilities: List[Capability]=None, ResourceTypes: List[ResourceType]=None, RoleARN: str=None, OnFailure: str=None, StackPolicyBody: str=None, StackPolicyURL: str=None, Tags: List[Tag]=None, ClientRequestToken: str=None, EnableTerminationProtection: EnableTerminationProtection=None) -> CreateStackOutput:
        pass

    def create_stack_instances(self, Regions: List[Region], Accounts: List[Account], StackSetName: str, ParameterOverrides: List[Parameter]=None, OperationPreferences: StackSetOperationPreferences=None, OperationId: str=None) -> CreateStackInstancesOutput:
        pass

    def create_stack_set(self, StackSetName: str, Description: str=None, TemplateBody: str=None, TemplateURL: str=None, Parameters: List[Parameter]=None, Capabilities: List[Capability]=None, Tags: List[Tag]=None, AdministrationRoleARN: str=None, ExecutionRoleName: str=None, ClientRequestToken: str=None) -> CreateStackSetOutput:
        pass

    def delete_change_set(self, ChangeSetName: str, StackName: str=None) -> DeleteChangeSetOutput:
        pass

    def delete_stack(self, StackName: str, RetainResources: List[LogicalResourceId]=None, RoleARN: str=None, ClientRequestToken: str=None):
        pass

    def delete_stack_instances(self, RetainStacks: RetainStacks, Regions: List[Region], Accounts: List[Account], StackSetName: str, OperationPreferences: StackSetOperationPreferences=None, OperationId: str=None) -> DeleteStackInstancesOutput:
        pass

    def delete_stack_set(self, StackSetName: str) -> DeleteStackSetOutput:
        pass

    def describe_account_limits(self, NextToken: str=None) -> DescribeAccountLimitsOutput:
        pass

    def describe_change_set(self, ChangeSetName: str, StackName: str=None, NextToken: str=None) -> DescribeChangeSetOutput:
        pass

    def describe_stack_drift_detection_status(self, StackDriftDetectionId: str) -> DescribeStackDriftDetectionStatusOutput:
        pass

    def describe_stack_events(self, StackName: str=None, NextToken: str=None) -> DescribeStackEventsOutput:
        pass

    def describe_stack_instance(self, StackInstanceRegion: str, StackInstanceAccount: str, StackSetName: str) -> DescribeStackInstanceOutput:
        pass

    def describe_stack_resource(self, LogicalResourceId: str, StackName: str) -> DescribeStackResourceOutput:
        pass

    def describe_stack_resource_drifts(self, StackName: str, StackResourceDriftStatusFilters: List[StackResourceDriftStatus]=None, NextToken: str=None, MaxResults: int=None) -> DescribeStackResourceDriftsOutput:
        pass

    def describe_stack_resources(self, StackName: str=None, LogicalResourceId: str=None, PhysicalResourceId: str=None) -> DescribeStackResourcesOutput:
        pass

    def describe_stack_set(self, StackSetName: str) -> DescribeStackSetOutput:
        pass

    def describe_stack_set_operation(self, OperationId: str, StackSetName: str) -> DescribeStackSetOperationOutput:
        pass

    def describe_stacks(self, StackName: str=None, NextToken: str=None) -> DescribeStacksOutput:
        pass

    def detect_stack_drift(self, StackName: str, LogicalResourceIds: List[LogicalResourceId]=None) -> DetectStackDriftOutput:
        pass

    def detect_stack_resource_drift(self, LogicalResourceId: str, StackName: str) -> DetectStackResourceDriftOutput:
        pass

    def estimate_template_cost(self, TemplateBody: str=None, TemplateURL: str=None, Parameters: List[Parameter]=None) -> EstimateTemplateCostOutput:
        pass

    def execute_change_set(self, ChangeSetName: str, StackName: str=None, ClientRequestToken: str=None) -> ExecuteChangeSetOutput:
        pass

    def get_stack_policy(self, StackName: str) -> GetStackPolicyOutput:
        pass

    def get_template(self, StackName: str=None, ChangeSetName: str=None, TemplateStage: str=None) -> GetTemplateOutput:
        pass

    def get_template_summary(self, TemplateBody: str=None, TemplateURL: str=None, StackName: str=None, StackSetName: str=None) -> GetTemplateSummaryOutput:
        pass

    def list_change_sets(self, StackName: str, NextToken: str=None) -> ListChangeSetsOutput:
        pass

    def list_exports(self, NextToken: str=None) -> ListExportsOutput:
        pass

    def list_imports(self, ExportName: str, NextToken: str=None) -> ListImportsOutput:
        pass

    def list_stack_instances(self, StackSetName: str, NextToken: str=None, MaxResults: int=None, StackInstanceAccount: str=None, StackInstanceRegion: str=None) -> ListStackInstancesOutput:
        pass

    def list_stack_resources(self, StackName: str, NextToken: str=None) -> ListStackResourcesOutput:
        pass

    def list_stack_set_operation_results(self, OperationId: str, StackSetName: str, NextToken: str=None, MaxResults: int=None) -> ListStackSetOperationResultsOutput:
        pass

    def list_stack_set_operations(self, StackSetName: str, NextToken: str=None, MaxResults: int=None) -> ListStackSetOperationsOutput:
        pass

    def list_stack_sets(self, NextToken: str=None, MaxResults: int=None, Status: str=None) -> ListStackSetsOutput:
        pass

    def list_stacks(self, NextToken: str=None, StackStatusFilter: List[StackStatus]=None) -> ListStacksOutput:
        pass

    def set_stack_policy(self, StackName: str, StackPolicyBody: str=None, StackPolicyURL: str=None):
        pass

    def signal_resource(self, Status: str, UniqueId: str, LogicalResourceId: str, StackName: str):
        pass

    def stop_stack_set_operation(self, OperationId: str, StackSetName: str) -> StopStackSetOperationOutput:
        pass

    def update_stack(self, StackName: str, TemplateBody: str=None, TemplateURL: str=None, UsePreviousTemplate: UsePreviousTemplate=None, StackPolicyDuringUpdateBody: str=None, StackPolicyDuringUpdateURL: str=None, Parameters: List[Parameter]=None, Capabilities: List[Capability]=None, ResourceTypes: List[ResourceType]=None, RoleARN: str=None, RollbackConfiguration: RollbackConfiguration=None, StackPolicyBody: str=None, StackPolicyURL: str=None, NotificationARNs: List[NotificationARN]=None, Tags: List[Tag]=None, ClientRequestToken: str=None) -> UpdateStackOutput:
        pass

    def update_stack_instances(self, Regions: List[Region], Accounts: List[Account], StackSetName: str, ParameterOverrides: List[Parameter]=None, OperationPreferences: StackSetOperationPreferences=None, OperationId: str=None) -> UpdateStackInstancesOutput:
        pass

    def update_stack_set(self, StackSetName: str, Description: str=None, TemplateBody: str=None, TemplateURL: str=None, UsePreviousTemplate: UsePreviousTemplate=None, Parameters: List[Parameter]=None, Capabilities: List[Capability]=None, Tags: List[Tag]=None, OperationPreferences: StackSetOperationPreferences=None, AdministrationRoleARN: str=None, ExecutionRoleName: str=None, OperationId: str=None, Accounts: List[Account]=None, Regions: List[Region]=None) -> UpdateStackSetOutput:
        pass

    def update_termination_protection(self, StackName: str, EnableTerminationProtection: EnableTerminationProtection) -> UpdateTerminationProtectionOutput:
        pass

    def validate_template(self, TemplateBody: str=None, TemplateURL: str=None) -> ValidateTemplateOutput:
        pass


class CloudFront(BaseClient):
    class CreateCloudFrontOriginAccessIdentityRequest(Mapping):
        pass

    class CreateCloudFrontOriginAccessIdentityResult(Mapping):
        pass

    class CloudFrontOriginAccessIdentityConfig(Mapping):
        pass

    class CreateDistributionRequest(Mapping):
        pass

    class CreateDistributionResult(Mapping):
        pass

    class DistributionConfig(Mapping):
        pass

    class CreateDistributionWithTagsRequest(Mapping):
        pass

    class CreateDistributionWithTagsResult(Mapping):
        pass

    class DistributionConfigWithTags(Mapping):
        pass

    class CreateFieldLevelEncryptionConfigRequest(Mapping):
        pass

    class CreateFieldLevelEncryptionConfigResult(Mapping):
        pass

    class FieldLevelEncryptionConfig(Mapping):
        pass

    class CreateFieldLevelEncryptionProfileRequest(Mapping):
        pass

    class CreateFieldLevelEncryptionProfileResult(Mapping):
        pass

    class FieldLevelEncryptionProfileConfig(Mapping):
        pass

    class CreateInvalidationRequest(Mapping):
        pass

    class CreateInvalidationResult(Mapping):
        pass

    class InvalidationBatch(Mapping):
        pass

    class CreatePublicKeyRequest(Mapping):
        pass

    class CreatePublicKeyResult(Mapping):
        pass

    class PublicKeyConfig(Mapping):
        pass

    class CreateStreamingDistributionRequest(Mapping):
        pass

    class CreateStreamingDistributionResult(Mapping):
        pass

    class StreamingDistributionConfig(Mapping):
        pass

    class CreateStreamingDistributionWithTagsRequest(Mapping):
        pass

    class CreateStreamingDistributionWithTagsResult(Mapping):
        pass

    class StreamingDistributionConfigWithTags(Mapping):
        pass

    class DeleteCloudFrontOriginAccessIdentityRequest(Mapping):
        pass

    class DeleteDistributionRequest(Mapping):
        pass

    class DeleteFieldLevelEncryptionConfigRequest(Mapping):
        pass

    class DeleteFieldLevelEncryptionProfileRequest(Mapping):
        pass

    class DeletePublicKeyRequest(Mapping):
        pass

    class DeleteStreamingDistributionRequest(Mapping):
        pass

    class GetCloudFrontOriginAccessIdentityRequest(Mapping):
        pass

    class GetCloudFrontOriginAccessIdentityResult(Mapping):
        pass

    class GetCloudFrontOriginAccessIdentityConfigRequest(Mapping):
        pass

    class GetCloudFrontOriginAccessIdentityConfigResult(Mapping):
        pass

    class GetDistributionRequest(Mapping):
        pass

    class GetDistributionResult(Mapping):
        pass

    class GetDistributionConfigRequest(Mapping):
        pass

    class GetDistributionConfigResult(Mapping):
        pass

    class GetFieldLevelEncryptionRequest(Mapping):
        pass

    class GetFieldLevelEncryptionResult(Mapping):
        pass

    class GetFieldLevelEncryptionConfigRequest(Mapping):
        pass

    class GetFieldLevelEncryptionConfigResult(Mapping):
        pass

    class GetFieldLevelEncryptionProfileRequest(Mapping):
        pass

    class GetFieldLevelEncryptionProfileResult(Mapping):
        pass

    class GetFieldLevelEncryptionProfileConfigRequest(Mapping):
        pass

    class GetFieldLevelEncryptionProfileConfigResult(Mapping):
        pass

    class GetInvalidationRequest(Mapping):
        pass

    class GetInvalidationResult(Mapping):
        pass

    class GetPublicKeyRequest(Mapping):
        pass

    class GetPublicKeyResult(Mapping):
        pass

    class GetPublicKeyConfigRequest(Mapping):
        pass

    class GetPublicKeyConfigResult(Mapping):
        pass

    class GetStreamingDistributionRequest(Mapping):
        pass

    class GetStreamingDistributionResult(Mapping):
        pass

    class GetStreamingDistributionConfigRequest(Mapping):
        pass

    class GetStreamingDistributionConfigResult(Mapping):
        pass

    class ListCloudFrontOriginAccessIdentitiesRequest(Mapping):
        pass

    class ListCloudFrontOriginAccessIdentitiesResult(Mapping):
        pass

    class ListDistributionsRequest(Mapping):
        pass

    class ListDistributionsResult(Mapping):
        pass

    class ListDistributionsByWebACLIdRequest(Mapping):
        pass

    class ListDistributionsByWebACLIdResult(Mapping):
        pass

    class ListFieldLevelEncryptionConfigsRequest(Mapping):
        pass

    class ListFieldLevelEncryptionConfigsResult(Mapping):
        pass

    class ListFieldLevelEncryptionProfilesRequest(Mapping):
        pass

    class ListFieldLevelEncryptionProfilesResult(Mapping):
        pass

    class ListInvalidationsRequest(Mapping):
        pass

    class ListInvalidationsResult(Mapping):
        pass

    class ListPublicKeysRequest(Mapping):
        pass

    class ListPublicKeysResult(Mapping):
        pass

    class ListStreamingDistributionsRequest(Mapping):
        pass

    class ListStreamingDistributionsResult(Mapping):
        pass

    class ListTagsForResourceRequest(Mapping):
        pass

    class ListTagsForResourceResult(Mapping):
        pass

    class TagResourceRequest(Mapping):
        pass

    class Tags(Mapping):
        pass

    class UntagResourceRequest(Mapping):
        pass

    class TagKeys(Mapping):
        pass

    class UpdateCloudFrontOriginAccessIdentityRequest(Mapping):
        pass

    class UpdateCloudFrontOriginAccessIdentityResult(Mapping):
        pass

    class UpdateDistributionRequest(Mapping):
        pass

    class UpdateDistributionResult(Mapping):
        pass

    class UpdateFieldLevelEncryptionConfigRequest(Mapping):
        pass

    class UpdateFieldLevelEncryptionConfigResult(Mapping):
        pass

    class UpdateFieldLevelEncryptionProfileRequest(Mapping):
        pass

    class UpdateFieldLevelEncryptionProfileResult(Mapping):
        pass

    class UpdatePublicKeyRequest(Mapping):
        pass

    class UpdatePublicKeyResult(Mapping):
        pass

    class UpdateStreamingDistributionRequest(Mapping):
        pass

    class UpdateStreamingDistributionResult(Mapping):
        pass

    def create_cloud_front_origin_access_identity(self, CloudFrontOriginAccessIdentityConfig: CloudFrontOriginAccessIdentityConfig) -> CreateCloudFrontOriginAccessIdentityResult:
        pass

    def create_distribution(self, DistributionConfig: DistributionConfig) -> CreateDistributionResult:
        pass

    def create_distribution_with_tags(self, DistributionConfigWithTags: DistributionConfigWithTags) -> CreateDistributionWithTagsResult:
        pass

    def create_field_level_encryption_config(self, FieldLevelEncryptionConfig: FieldLevelEncryptionConfig) -> CreateFieldLevelEncryptionConfigResult:
        pass

    def create_field_level_encryption_profile(self, FieldLevelEncryptionProfileConfig: FieldLevelEncryptionProfileConfig) -> CreateFieldLevelEncryptionProfileResult:
        pass

    def create_invalidation(self, InvalidationBatch: InvalidationBatch, DistributionId: str) -> CreateInvalidationResult:
        pass

    def create_public_key(self, PublicKeyConfig: PublicKeyConfig) -> CreatePublicKeyResult:
        pass

    def create_streaming_distribution(self, StreamingDistributionConfig: StreamingDistributionConfig) -> CreateStreamingDistributionResult:
        pass

    def create_streaming_distribution_with_tags(self, StreamingDistributionConfigWithTags: StreamingDistributionConfigWithTags) -> CreateStreamingDistributionWithTagsResult:
        pass

    def delete_cloud_front_origin_access_identity(self, Id: str, IfMatch: str=None):
        pass

    def delete_distribution(self, Id: str, IfMatch: str=None):
        pass

    def delete_field_level_encryption_config(self, Id: str, IfMatch: str=None):
        pass

    def delete_field_level_encryption_profile(self, Id: str, IfMatch: str=None):
        pass

    def delete_public_key(self, Id: str, IfMatch: str=None):
        pass

    def delete_streaming_distribution(self, Id: str, IfMatch: str=None):
        pass

    def get_cloud_front_origin_access_identity(self, Id: str) -> GetCloudFrontOriginAccessIdentityResult:
        pass

    def get_cloud_front_origin_access_identity_config(self, Id: str) -> GetCloudFrontOriginAccessIdentityConfigResult:
        pass

    def get_distribution(self, Id: str) -> GetDistributionResult:
        pass

    def get_distribution_config(self, Id: str) -> GetDistributionConfigResult:
        pass

    def get_field_level_encryption(self, Id: str) -> GetFieldLevelEncryptionResult:
        pass

    def get_field_level_encryption_config(self, Id: str) -> GetFieldLevelEncryptionConfigResult:
        pass

    def get_field_level_encryption_profile(self, Id: str) -> GetFieldLevelEncryptionProfileResult:
        pass

    def get_field_level_encryption_profile_config(self, Id: str) -> GetFieldLevelEncryptionProfileConfigResult:
        pass

    def get_invalidation(self, Id: str, DistributionId: str) -> GetInvalidationResult:
        pass

    def get_public_key(self, Id: str) -> GetPublicKeyResult:
        pass

    def get_public_key_config(self, Id: str) -> GetPublicKeyConfigResult:
        pass

    def get_streaming_distribution(self, Id: str) -> GetStreamingDistributionResult:
        pass

    def get_streaming_distribution_config(self, Id: str) -> GetStreamingDistributionConfigResult:
        pass

    def list_cloud_front_origin_access_identities(self, Marker: str=None, MaxItems: str=None) -> ListCloudFrontOriginAccessIdentitiesResult:
        pass

    def list_distributions(self, Marker: str=None, MaxItems: str=None) -> ListDistributionsResult:
        pass

    def list_distributions_by_web_acl_id(self, WebACLId: str, Marker: str=None, MaxItems: str=None) -> ListDistributionsByWebACLIdResult:
        pass

    def list_field_level_encryption_configs(self, Marker: str=None, MaxItems: str=None) -> ListFieldLevelEncryptionConfigsResult:
        pass

    def list_field_level_encryption_profiles(self, Marker: str=None, MaxItems: str=None) -> ListFieldLevelEncryptionProfilesResult:
        pass

    def list_invalidations(self, DistributionId: str, Marker: str=None, MaxItems: str=None) -> ListInvalidationsResult:
        pass

    def list_public_keys(self, Marker: str=None, MaxItems: str=None) -> ListPublicKeysResult:
        pass

    def list_streaming_distributions(self, Marker: str=None, MaxItems: str=None) -> ListStreamingDistributionsResult:
        pass

    def list_tags_for_resource(self, Resource: str) -> ListTagsForResourceResult:
        pass

    def tag_resource(self, Tags: Tags, Resource: str):
        pass

    def untag_resource(self, TagKeys: TagKeys, Resource: str):
        pass

    def update_cloud_front_origin_access_identity(self, Id: str, CloudFrontOriginAccessIdentityConfig: CloudFrontOriginAccessIdentityConfig, IfMatch: str=None) -> UpdateCloudFrontOriginAccessIdentityResult:
        pass

    def update_distribution(self, Id: str, DistributionConfig: DistributionConfig, IfMatch: str=None) -> UpdateDistributionResult:
        pass

    def update_field_level_encryption_config(self, Id: str, FieldLevelEncryptionConfig: FieldLevelEncryptionConfig, IfMatch: str=None) -> UpdateFieldLevelEncryptionConfigResult:
        pass

    def update_field_level_encryption_profile(self, Id: str, FieldLevelEncryptionProfileConfig: FieldLevelEncryptionProfileConfig, IfMatch: str=None) -> UpdateFieldLevelEncryptionProfileResult:
        pass

    def update_public_key(self, Id: str, PublicKeyConfig: PublicKeyConfig, IfMatch: str=None) -> UpdatePublicKeyResult:
        pass

    def update_streaming_distribution(self, Id: str, StreamingDistributionConfig: StreamingDistributionConfig, IfMatch: str=None) -> UpdateStreamingDistributionResult:
        pass


class CloudHSM(BaseClient):
    class AddTagsToResourceRequest(Mapping):
        pass

    class AddTagsToResourceResponse(Mapping):
        pass

    class Tag(Mapping):
        pass

    class CreateHapgRequest(Mapping):
        pass

    class CreateHapgResponse(Mapping):
        pass

    class CreateHsmRequest(Mapping):
        pass

    class CreateHsmResponse(Mapping):
        pass

    class CreateLunaClientRequest(Mapping):
        pass

    class CreateLunaClientResponse(Mapping):
        pass

    class DeleteHapgRequest(Mapping):
        pass

    class DeleteHapgResponse(Mapping):
        pass

    class DeleteHsmRequest(Mapping):
        pass

    class DeleteHsmResponse(Mapping):
        pass

    class DeleteLunaClientRequest(Mapping):
        pass

    class DeleteLunaClientResponse(Mapping):
        pass

    class DescribeHapgRequest(Mapping):
        pass

    class DescribeHapgResponse(Mapping):
        pass

    class DescribeHsmRequest(Mapping):
        pass

    class DescribeHsmResponse(Mapping):
        pass

    class DescribeLunaClientRequest(Mapping):
        pass

    class DescribeLunaClientResponse(Mapping):
        pass

    class GetConfigRequest(Mapping):
        pass

    class GetConfigResponse(Mapping):
        pass

    class HapgArn(object):
        pass

    class ListAvailableZonesRequest(Mapping):
        pass

    class ListAvailableZonesResponse(Mapping):
        pass

    class ListHapgsRequest(Mapping):
        pass

    class ListHapgsResponse(Mapping):
        pass

    class ListHsmsRequest(Mapping):
        pass

    class ListHsmsResponse(Mapping):
        pass

    class ListLunaClientsRequest(Mapping):
        pass

    class ListLunaClientsResponse(Mapping):
        pass

    class ListTagsForResourceRequest(Mapping):
        pass

    class ListTagsForResourceResponse(Mapping):
        pass

    class ModifyHapgRequest(Mapping):
        pass

    class ModifyHapgResponse(Mapping):
        pass

    class PartitionSerial(object):
        pass

    class ModifyHsmRequest(Mapping):
        pass

    class ModifyHsmResponse(Mapping):
        pass

    class ModifyLunaClientRequest(Mapping):
        pass

    class ModifyLunaClientResponse(Mapping):
        pass

    class RemoveTagsFromResourceRequest(Mapping):
        pass

    class RemoveTagsFromResourceResponse(Mapping):
        pass

    class TagKey(object):
        pass

    def add_tags_to_resource(self, TagList: List[Tag], ResourceArn: str) -> AddTagsToResourceResponse:
        pass

    def create_hapg(self, Label: str) -> CreateHapgResponse:
        pass

    def create_hsm(self, SubscriptionType: str, IamRoleArn: str, SshKey: str, SubnetId: str, EniIp: str=None, ExternalId: str=None, ClientToken: str=None, SyslogIp: str=None) -> CreateHsmResponse:
        pass

    def create_luna_client(self, Certificate: str, Label: str=None) -> CreateLunaClientResponse:
        pass

    def delete_hapg(self, HapgArn: str) -> DeleteHapgResponse:
        pass

    def delete_hsm(self, HsmArn: str) -> DeleteHsmResponse:
        pass

    def delete_luna_client(self, ClientArn: str) -> DeleteLunaClientResponse:
        pass

    def describe_hapg(self, HapgArn: str) -> DescribeHapgResponse:
        pass

    def describe_hsm(self, HsmArn: str=None, HsmSerialNumber: str=None) -> DescribeHsmResponse:
        pass

    def describe_luna_client(self, ClientArn: str=None, CertificateFingerprint: str=None) -> DescribeLunaClientResponse:
        pass

    def get_config(self, HapgList: List[HapgArn], ClientVersion: str, ClientArn: str) -> GetConfigResponse:
        pass

    def list_available_zones(self) -> ListAvailableZonesResponse:
        pass

    def list_hapgs(self, NextToken: str=None) -> ListHapgsResponse:
        pass

    def list_hsms(self, NextToken: str=None) -> ListHsmsResponse:
        pass

    def list_luna_clients(self, NextToken: str=None) -> ListLunaClientsResponse:
        pass

    def list_tags_for_resource(self, ResourceArn: str) -> ListTagsForResourceResponse:
        pass

    def modify_hapg(self, HapgArn: str, Label: str=None, PartitionSerialList: List[PartitionSerial]=None) -> ModifyHapgResponse:
        pass

    def modify_hsm(self, HsmArn: str, SubnetId: str=None, EniIp: str=None, IamRoleArn: str=None, ExternalId: str=None, SyslogIp: str=None) -> ModifyHsmResponse:
        pass

    def modify_luna_client(self, Certificate: str, ClientArn: str) -> ModifyLunaClientResponse:
        pass

    def remove_tags_from_resource(self, TagKeyList: List[TagKey], ResourceArn: str) -> RemoveTagsFromResourceResponse:
        pass


class CloudHSMV2(BaseClient):
    class CopyBackupToRegionRequest(Mapping):
        pass

    class CopyBackupToRegionResponse(Mapping):
        pass

    class CreateClusterRequest(Mapping):
        pass

    class CreateClusterResponse(Mapping):
        pass

    class SubnetId(object):
        pass

    class CreateHsmRequest(Mapping):
        pass

    class CreateHsmResponse(Mapping):
        pass

    class DeleteBackupRequest(Mapping):
        pass

    class DeleteBackupResponse(Mapping):
        pass

    class DeleteClusterRequest(Mapping):
        pass

    class DeleteClusterResponse(Mapping):
        pass

    class DeleteHsmRequest(Mapping):
        pass

    class DeleteHsmResponse(Mapping):
        pass

    class DescribeBackupsRequest(Mapping):
        pass

    class DescribeBackupsResponse(Mapping):
        pass

    class Filters(object):
        pass

    class Boolean(object):
        pass

    class DescribeClustersRequest(Mapping):
        pass

    class DescribeClustersResponse(Mapping):
        pass

    class InitializeClusterRequest(Mapping):
        pass

    class InitializeClusterResponse(Mapping):
        pass

    class ListTagsRequest(Mapping):
        pass

    class ListTagsResponse(Mapping):
        pass

    class RestoreBackupRequest(Mapping):
        pass

    class RestoreBackupResponse(Mapping):
        pass

    class TagResourceRequest(Mapping):
        pass

    class TagResourceResponse(Mapping):
        pass

    class Tag(Mapping):
        pass

    class UntagResourceRequest(Mapping):
        pass

    class UntagResourceResponse(Mapping):
        pass

    class TagKey(object):
        pass

    def copy_backup_to_region(self, BackupId: str, DestinationRegion: str) -> CopyBackupToRegionResponse:
        pass

    def create_cluster(self, HsmType: str, SubnetIds: List[SubnetId], SourceBackupId: str=None) -> CreateClusterResponse:
        pass

    def create_hsm(self, AvailabilityZone: str, ClusterId: str, IpAddress: str=None) -> CreateHsmResponse:
        pass

    def delete_backup(self, BackupId: str) -> DeleteBackupResponse:
        pass

    def delete_cluster(self, ClusterId: str) -> DeleteClusterResponse:
        pass

    def delete_hsm(self, ClusterId: str, HsmId: str=None, EniId: str=None, EniIp: str=None) -> DeleteHsmResponse:
        pass

    def describe_backups(self, NextToken: str=None, MaxResults: int=None, Filters: Filters=None, SortAscending: Boolean=None) -> DescribeBackupsResponse:
        pass

    def describe_clusters(self, Filters: Filters=None, NextToken: str=None, MaxResults: int=None) -> DescribeClustersResponse:
        pass

    def initialize_cluster(self, TrustAnchor: str, SignedCert: str, ClusterId: str) -> InitializeClusterResponse:
        pass

    def list_tags(self, ResourceId: str, NextToken: str=None, MaxResults: int=None) -> ListTagsResponse:
        pass

    def restore_backup(self, BackupId: str) -> RestoreBackupResponse:
        pass

    def tag_resource(self, TagList: List[Tag], ResourceId: str) -> TagResourceResponse:
        pass

    def untag_resource(self, TagKeyList: List[TagKey], ResourceId: str) -> UntagResourceResponse:
        pass


class CloudSearch(BaseClient):
    class BuildSuggestersRequest(Mapping):
        pass

    class BuildSuggestersResponse(Mapping):
        pass

    class CreateDomainRequest(Mapping):
        pass

    class CreateDomainResponse(Mapping):
        pass

    class DefineAnalysisSchemeRequest(Mapping):
        pass

    class DefineAnalysisSchemeResponse(Mapping):
        pass

    class AnalysisScheme(Mapping):
        pass

    class DefineExpressionRequest(Mapping):
        pass

    class DefineExpressionResponse(Mapping):
        pass

    class Expression(Mapping):
        pass

    class DefineIndexFieldRequest(Mapping):
        pass

    class DefineIndexFieldResponse(Mapping):
        pass

    class IndexField(Mapping):
        pass

    class DefineSuggesterRequest(Mapping):
        pass

    class DefineSuggesterResponse(Mapping):
        pass

    class Suggester(Mapping):
        pass

    class DeleteAnalysisSchemeRequest(Mapping):
        pass

    class DeleteAnalysisSchemeResponse(Mapping):
        pass

    class DeleteDomainRequest(Mapping):
        pass

    class DeleteDomainResponse(Mapping):
        pass

    class DeleteExpressionRequest(Mapping):
        pass

    class DeleteExpressionResponse(Mapping):
        pass

    class DeleteIndexFieldRequest(Mapping):
        pass

    class DeleteIndexFieldResponse(Mapping):
        pass

    class DeleteSuggesterRequest(Mapping):
        pass

    class DeleteSuggesterResponse(Mapping):
        pass

    class DescribeAnalysisSchemesRequest(Mapping):
        pass

    class DescribeAnalysisSchemesResponse(Mapping):
        pass

    class StandardName(object):
        pass

    class Boolean(object):
        pass

    class DescribeAvailabilityOptionsRequest(Mapping):
        pass

    class DescribeAvailabilityOptionsResponse(Mapping):
        pass

    class DescribeDomainsRequest(Mapping):
        pass

    class DescribeDomainsResponse(Mapping):
        pass

    class DomainName(object):
        pass

    class DescribeExpressionsRequest(Mapping):
        pass

    class DescribeExpressionsResponse(Mapping):
        pass

    class DescribeIndexFieldsRequest(Mapping):
        pass

    class DescribeIndexFieldsResponse(Mapping):
        pass

    class DynamicFieldName(object):
        pass

    class DescribeScalingParametersRequest(Mapping):
        pass

    class DescribeScalingParametersResponse(Mapping):
        pass

    class DescribeServiceAccessPoliciesRequest(Mapping):
        pass

    class DescribeServiceAccessPoliciesResponse(Mapping):
        pass

    class DescribeSuggestersRequest(Mapping):
        pass

    class DescribeSuggestersResponse(Mapping):
        pass

    class IndexDocumentsRequest(Mapping):
        pass

    class IndexDocumentsResponse(Mapping):
        pass

    class ListDomainNamesResponse(Mapping):
        pass

    class UpdateAvailabilityOptionsRequest(Mapping):
        pass

    class UpdateAvailabilityOptionsResponse(Mapping):
        pass

    class UpdateScalingParametersRequest(Mapping):
        pass

    class UpdateScalingParametersResponse(Mapping):
        pass

    class ScalingParameters(Mapping):
        pass

    class UpdateServiceAccessPoliciesRequest(Mapping):
        pass

    class UpdateServiceAccessPoliciesResponse(Mapping):
        pass

    def build_suggesters(self, DomainName: str) -> BuildSuggestersResponse:
        pass

    def create_domain(self, DomainName: str) -> CreateDomainResponse:
        pass

    def define_analysis_scheme(self, AnalysisScheme: AnalysisScheme, DomainName: str) -> DefineAnalysisSchemeResponse:
        pass

    def define_expression(self, Expression: Expression, DomainName: str) -> DefineExpressionResponse:
        pass

    def define_index_field(self, IndexField: IndexField, DomainName: str) -> DefineIndexFieldResponse:
        pass

    def define_suggester(self, Suggester: Suggester, DomainName: str) -> DefineSuggesterResponse:
        pass

    def delete_analysis_scheme(self, AnalysisSchemeName: str, DomainName: str) -> DeleteAnalysisSchemeResponse:
        pass

    def delete_domain(self, DomainName: str) -> DeleteDomainResponse:
        pass

    def delete_expression(self, ExpressionName: str, DomainName: str) -> DeleteExpressionResponse:
        pass

    def delete_index_field(self, IndexFieldName: str, DomainName: str) -> DeleteIndexFieldResponse:
        pass

    def delete_suggester(self, SuggesterName: str, DomainName: str) -> DeleteSuggesterResponse:
        pass

    def describe_analysis_schemes(self, DomainName: str, AnalysisSchemeNames: List[StandardName]=None, Deployed: Boolean=None) -> DescribeAnalysisSchemesResponse:
        pass

    def describe_availability_options(self, DomainName: str, Deployed: Boolean=None) -> DescribeAvailabilityOptionsResponse:
        pass

    def describe_domains(self, DomainNames: List[DomainName]=None) -> DescribeDomainsResponse:
        pass

    def describe_expressions(self, DomainName: str, ExpressionNames: List[StandardName]=None, Deployed: Boolean=None) -> DescribeExpressionsResponse:
        pass

    def describe_index_fields(self, DomainName: str, FieldNames: List[DynamicFieldName]=None, Deployed: Boolean=None) -> DescribeIndexFieldsResponse:
        pass

    def describe_scaling_parameters(self, DomainName: str) -> DescribeScalingParametersResponse:
        pass

    def describe_service_access_policies(self, DomainName: str, Deployed: Boolean=None) -> DescribeServiceAccessPoliciesResponse:
        pass

    def describe_suggesters(self, DomainName: str, SuggesterNames: List[StandardName]=None, Deployed: Boolean=None) -> DescribeSuggestersResponse:
        pass

    def index_documents(self, DomainName: str) -> IndexDocumentsResponse:
        pass

    def list_domain_names(self) -> ListDomainNamesResponse:
        pass

    def update_availability_options(self, MultiAZ: Boolean, DomainName: str) -> UpdateAvailabilityOptionsResponse:
        pass

    def update_scaling_parameters(self, ScalingParameters: ScalingParameters, DomainName: str) -> UpdateScalingParametersResponse:
        pass

    def update_service_access_policies(self, AccessPolicies: str, DomainName: str) -> UpdateServiceAccessPoliciesResponse:
        pass


class CloudSearchDomain(BaseClient):
    class SearchRequest(Mapping):
        pass

    class SearchResponse(Mapping):
        pass

    class Partial(object):
        pass

    class Size(object):
        pass

    class Start(object):
        pass

    class SuggestRequest(Mapping):
        pass

    class SuggestResponse(Mapping):
        pass

    class SuggestionsSize(object):
        pass

    class UploadDocumentsRequest(Mapping):
        pass

    class UploadDocumentsResponse(Mapping):
        pass

    class Blob(object):
        pass

    def search(self, query: str, cursor: str=None, expr: str=None, facet: str=None, filterQuery: str=None, highlight: str=None, partial: Partial=None, queryOptions: str=None, queryParser: str=None, return_: str=None, size: Size=None, sort: str=None, start: Start=None, stats: str=None) -> SearchResponse:
        pass

    def suggest(self, suggester: str, query: str, size: SuggestionsSize=None) -> SuggestResponse:
        pass

    def upload_documents(self, contentType: str, documents: Blob) -> UploadDocumentsResponse:
        pass


class CloudTrail(BaseClient):
    class AddTagsRequest(Mapping):
        pass

    class AddTagsResponse(Mapping):
        pass

    class Tag(Mapping):
        pass

    class CreateTrailRequest(Mapping):
        pass

    class CreateTrailResponse(Mapping):
        pass

    class Boolean(object):
        pass

    class DeleteTrailRequest(Mapping):
        pass

    class DeleteTrailResponse(Mapping):
        pass

    class DescribeTrailsRequest(Mapping):
        pass

    class DescribeTrailsResponse(Mapping):
        pass

    class String(object):
        pass

    class GetEventSelectorsRequest(Mapping):
        pass

    class GetEventSelectorsResponse(Mapping):
        pass

    class GetTrailStatusRequest(Mapping):
        pass

    class GetTrailStatusResponse(Mapping):
        pass

    class ListPublicKeysRequest(Mapping):
        pass

    class ListPublicKeysResponse(Mapping):
        pass

    class Date(object):
        pass

    class ListTagsRequest(Mapping):
        pass

    class ListTagsResponse(Mapping):
        pass

    class LookupEventsRequest(Mapping):
        pass

    class LookupEventsResponse(Mapping):
        pass

    class LookupAttribute(Mapping):
        pass

    class PutEventSelectorsRequest(Mapping):
        pass

    class PutEventSelectorsResponse(Mapping):
        pass

    class EventSelector(Mapping):
        pass

    class RemoveTagsRequest(Mapping):
        pass

    class RemoveTagsResponse(Mapping):
        pass

    class StartLoggingRequest(Mapping):
        pass

    class StartLoggingResponse(Mapping):
        pass

    class StopLoggingRequest(Mapping):
        pass

    class StopLoggingResponse(Mapping):
        pass

    class UpdateTrailRequest(Mapping):
        pass

    class UpdateTrailResponse(Mapping):
        pass

    def add_tags(self, ResourceId: str, TagsList: List[Tag]=None) -> AddTagsResponse:
        pass

    def create_trail(self, S3BucketName: str, Name: str, S3KeyPrefix: str=None, SnsTopicName: str=None, IncludeGlobalServiceEvents: Boolean=None, IsMultiRegionTrail: Boolean=None, EnableLogFileValidation: Boolean=None, CloudWatchLogsLogGroupArn: str=None, CloudWatchLogsRoleArn: str=None, KmsKeyId: str=None, IsOrganizationTrail: Boolean=None) -> CreateTrailResponse:
        pass

    def delete_trail(self, Name: str) -> DeleteTrailResponse:
        pass

    def describe_trails(self, trailNameList: List[String]=None, includeShadowTrails: Boolean=None) -> DescribeTrailsResponse:
        pass

    def get_event_selectors(self, TrailName: str) -> GetEventSelectorsResponse:
        pass

    def get_trail_status(self, Name: str) -> GetTrailStatusResponse:
        pass

    def list_public_keys(self, StartTime: Date=None, EndTime: Date=None, NextToken: str=None) -> ListPublicKeysResponse:
        pass

    def list_tags(self, ResourceIdList: List[String], NextToken: str=None) -> ListTagsResponse:
        pass

    def lookup_events(self, LookupAttributes: List[LookupAttribute]=None, StartTime: Date=None, EndTime: Date=None, MaxResults: int=None, NextToken: str=None) -> LookupEventsResponse:
        pass

    def put_event_selectors(self, EventSelectors: List[EventSelector], TrailName: str) -> PutEventSelectorsResponse:
        pass

    def remove_tags(self, ResourceId: str, TagsList: List[Tag]=None) -> RemoveTagsResponse:
        pass

    def start_logging(self, Name: str) -> StartLoggingResponse:
        pass

    def stop_logging(self, Name: str) -> StopLoggingResponse:
        pass

    def update_trail(self, Name: str, S3BucketName: str=None, S3KeyPrefix: str=None, SnsTopicName: str=None, IncludeGlobalServiceEvents: Boolean=None, IsMultiRegionTrail: Boolean=None, EnableLogFileValidation: Boolean=None, CloudWatchLogsLogGroupArn: str=None, CloudWatchLogsRoleArn: str=None, KmsKeyId: str=None, IsOrganizationTrail: Boolean=None) -> UpdateTrailResponse:
        pass


class CloudWatch(BaseClient):
    class DeleteAlarmsInput(Mapping):
        pass

    class AlarmName(object):
        pass

    class DeleteDashboardsInput(Mapping):
        pass

    class DeleteDashboardsOutput(Mapping):
        pass

    class DashboardName(object):
        pass

    class DescribeAlarmHistoryInput(Mapping):
        pass

    class DescribeAlarmHistoryOutput(Mapping):
        pass

    class Timestamp(object):
        pass

    class DescribeAlarmsInput(Mapping):
        pass

    class DescribeAlarmsOutput(Mapping):
        pass

    class DescribeAlarmsForMetricInput(Mapping):
        pass

    class DescribeAlarmsForMetricOutput(Mapping):
        pass

    class Dimension(Mapping):
        pass

    class DisableAlarmActionsInput(Mapping):
        pass

    class EnableAlarmActionsInput(Mapping):
        pass

    class GetDashboardInput(Mapping):
        pass

    class GetDashboardOutput(Mapping):
        pass

    class GetMetricDataInput(Mapping):
        pass

    class GetMetricDataOutput(Mapping):
        pass

    class MetricDataQuery(Mapping):
        pass

    class GetMetricStatisticsInput(Mapping):
        pass

    class GetMetricStatisticsOutput(Mapping):
        pass

    class Statistic(object):
        pass

    class ExtendedStatistic(object):
        pass

    class GetMetricWidgetImageInput(Mapping):
        pass

    class GetMetricWidgetImageOutput(Mapping):
        pass

    class ListDashboardsInput(Mapping):
        pass

    class ListDashboardsOutput(Mapping):
        pass

    class ListMetricsInput(Mapping):
        pass

    class ListMetricsOutput(Mapping):
        pass

    class DimensionFilter(Mapping):
        pass

    class PutDashboardInput(Mapping):
        pass

    class PutDashboardOutput(Mapping):
        pass

    class PutMetricAlarmInput(Mapping):
        pass

    class ActionsEnabled(object):
        pass

    class ResourceName(object):
        pass

    class Threshold(object):
        pass

    class PutMetricDataInput(Mapping):
        pass

    class MetricDatum(Mapping):
        pass

    class SetAlarmStateInput(Mapping):
        pass

    def delete_alarms(self, AlarmNames: List[AlarmName]):
        pass

    def delete_dashboards(self, DashboardNames: List[DashboardName]) -> DeleteDashboardsOutput:
        pass

    def describe_alarm_history(self, AlarmName: str=None, HistoryItemType: str=None, StartDate: Timestamp=None, EndDate: Timestamp=None, MaxRecords: int=None, NextToken: str=None) -> DescribeAlarmHistoryOutput:
        pass

    def describe_alarms(self, AlarmNames: List[AlarmName]=None, AlarmNamePrefix: str=None, StateValue: str=None, ActionPrefix: str=None, MaxRecords: int=None, NextToken: str=None) -> DescribeAlarmsOutput:
        pass

    def describe_alarms_for_metric(self, Namespace: str, MetricName: str, Statistic: str=None, ExtendedStatistic: str=None, Dimensions: List[Dimension]=None, Period: int=None, Unit: str=None) -> DescribeAlarmsForMetricOutput:
        pass

    def disable_alarm_actions(self, AlarmNames: List[AlarmName]):
        pass

    def enable_alarm_actions(self, AlarmNames: List[AlarmName]):
        pass

    def get_dashboard(self, DashboardName: str) -> GetDashboardOutput:
        pass

    def get_metric_data(self, EndTime: Timestamp, StartTime: Timestamp, MetricDataQueries: List[MetricDataQuery], NextToken: str=None, ScanBy: str=None, MaxDatapoints: int=None) -> GetMetricDataOutput:
        pass

    def get_metric_statistics(self, Period: int, EndTime: Timestamp, StartTime: Timestamp, MetricName: str, Namespace: str, Dimensions: List[Dimension]=None, Statistics: List[Statistic]=None, ExtendedStatistics: List[ExtendedStatistic]=None, Unit: str=None) -> GetMetricStatisticsOutput:
        pass

    def get_metric_widget_image(self, MetricWidget: str, OutputFormat: str=None) -> GetMetricWidgetImageOutput:
        pass

    def list_dashboards(self, DashboardNamePrefix: str=None, NextToken: str=None) -> ListDashboardsOutput:
        pass

    def list_metrics(self, Namespace: str=None, MetricName: str=None, Dimensions: List[DimensionFilter]=None, NextToken: str=None) -> ListMetricsOutput:
        pass

    def put_dashboard(self, DashboardBody: str, DashboardName: str) -> PutDashboardOutput:
        pass

    def put_metric_alarm(self, ComparisonOperator: str, Threshold: Threshold, EvaluationPeriods: int, AlarmName: str, AlarmDescription: str=None, ActionsEnabled: ActionsEnabled=None, OKActions: List[ResourceName]=None, AlarmActions: List[ResourceName]=None, InsufficientDataActions: List[ResourceName]=None, MetricName: str=None, Namespace: str=None, Statistic: str=None, ExtendedStatistic: str=None, Dimensions: List[Dimension]=None, Period: int=None, Unit: str=None, DatapointsToAlarm: int=None, TreatMissingData: str=None, EvaluateLowSampleCountPercentile: str=None, Metrics: List[MetricDataQuery]=None):
        pass

    def put_metric_data(self, MetricData: List[MetricDatum], Namespace: str):
        pass

    def set_alarm_state(self, StateReason: str, StateValue: str, AlarmName: str, StateReasonData: str=None):
        pass


class CodeBuild(BaseClient):
    class BatchDeleteBuildsInput(Mapping):
        pass

    class BatchDeleteBuildsOutput(Mapping):
        pass

    class NonEmptyString(object):
        pass

    class BatchGetBuildsInput(Mapping):
        pass

    class BatchGetBuildsOutput(Mapping):
        pass

    class BatchGetProjectsInput(Mapping):
        pass

    class BatchGetProjectsOutput(Mapping):
        pass

    class CreateProjectInput(Mapping):
        pass

    class CreateProjectOutput(Mapping):
        pass

    class ProjectSource(Mapping):
        pass

    class ProjectArtifacts(Mapping):
        pass

    class ProjectCache(Mapping):
        pass

    class ProjectEnvironment(Mapping):
        pass

    class Tag(Mapping):
        pass

    class VpcConfig(Mapping):
        pass

    class WrapperBoolean(object):
        pass

    class LogsConfig(Mapping):
        pass

    class CreateWebhookInput(Mapping):
        pass

    class CreateWebhookOutput(Mapping):
        pass

    class DeleteProjectInput(Mapping):
        pass

    class DeleteProjectOutput(Mapping):
        pass

    class DeleteSourceCredentialsInput(Mapping):
        pass

    class DeleteSourceCredentialsOutput(Mapping):
        pass

    class DeleteWebhookInput(Mapping):
        pass

    class DeleteWebhookOutput(Mapping):
        pass

    class ImportSourceCredentialsInput(Mapping):
        pass

    class ImportSourceCredentialsOutput(Mapping):
        pass

    class InvalidateProjectCacheInput(Mapping):
        pass

    class InvalidateProjectCacheOutput(Mapping):
        pass

    class ListBuildsInput(Mapping):
        pass

    class ListBuildsOutput(Mapping):
        pass

    class ListBuildsForProjectInput(Mapping):
        pass

    class ListBuildsForProjectOutput(Mapping):
        pass

    class ListCuratedEnvironmentImagesInput(Mapping):
        pass

    class ListCuratedEnvironmentImagesOutput(Mapping):
        pass

    class ListProjectsInput(Mapping):
        pass

    class ListProjectsOutput(Mapping):
        pass

    class ListSourceCredentialsInput(Mapping):
        pass

    class ListSourceCredentialsOutput(Mapping):
        pass

    class StartBuildInput(Mapping):
        pass

    class StartBuildOutput(Mapping):
        pass

    class ProjectSourceVersion(Mapping):
        pass

    class EnvironmentVariable(Mapping):
        pass

    class SourceAuth(Mapping):
        pass

    class RegistryCredential(Mapping):
        pass

    class StopBuildInput(Mapping):
        pass

    class StopBuildOutput(Mapping):
        pass

    class UpdateProjectInput(Mapping):
        pass

    class UpdateProjectOutput(Mapping):
        pass

    class UpdateWebhookInput(Mapping):
        pass

    class UpdateWebhookOutput(Mapping):
        pass

    class Boolean(object):
        pass

    def batch_delete_builds(self, ids: List[NonEmptyString]) -> BatchDeleteBuildsOutput:
        pass

    def batch_get_builds(self, ids: List[NonEmptyString]) -> BatchGetBuildsOutput:
        pass

    def batch_get_projects(self, names: List[NonEmptyString]) -> BatchGetProjectsOutput:
        pass

    def create_project(self, serviceRole: str, environment: ProjectEnvironment, artifacts: ProjectArtifacts, source: ProjectSource, name: str, description: str=None, secondarySources: List[ProjectSource]=None, secondaryArtifacts: List[ProjectArtifacts]=None, cache: ProjectCache=None, timeoutInMinutes: int=None, queuedTimeoutInMinutes: int=None, encryptionKey: str=None, tags: List[Tag]=None, vpcConfig: VpcConfig=None, badgeEnabled: WrapperBoolean=None, logsConfig: LogsConfig=None) -> CreateProjectOutput:
        pass

    def create_webhook(self, projectName: str, branchFilter: str=None) -> CreateWebhookOutput:
        pass

    def delete_project(self, name: str) -> DeleteProjectOutput:
        pass

    def delete_source_credentials(self, arn: str) -> DeleteSourceCredentialsOutput:
        pass

    def delete_webhook(self, projectName: str) -> DeleteWebhookOutput:
        pass

    def import_source_credentials(self, authType: str, serverType: str, token: str, username: str=None) -> ImportSourceCredentialsOutput:
        pass

    def invalidate_project_cache(self, projectName: str) -> InvalidateProjectCacheOutput:
        pass

    def list_builds(self, sortOrder: str=None, nextToken: str=None) -> ListBuildsOutput:
        pass

    def list_builds_for_project(self, projectName: str, sortOrder: str=None, nextToken: str=None) -> ListBuildsForProjectOutput:
        pass

    def list_curated_environment_images(self) -> ListCuratedEnvironmentImagesOutput:
        pass

    def list_projects(self, sortBy: str=None, sortOrder: str=None, nextToken: str=None) -> ListProjectsOutput:
        pass

    def list_source_credentials(self) -> ListSourceCredentialsOutput:
        pass

    def start_build(self, projectName: str, secondarySourcesOverride: List[ProjectSource]=None, secondarySourcesVersionOverride: List[ProjectSourceVersion]=None, sourceVersion: str=None, artifactsOverride: ProjectArtifacts=None, secondaryArtifactsOverride: List[ProjectArtifacts]=None, environmentVariablesOverride: List[EnvironmentVariable]=None, sourceTypeOverride: str=None, sourceLocationOverride: str=None, sourceAuthOverride: SourceAuth=None, gitCloneDepthOverride: int=None, buildspecOverride: str=None, insecureSslOverride: WrapperBoolean=None, reportBuildStatusOverride: WrapperBoolean=None, environmentTypeOverride: str=None, imageOverride: str=None, computeTypeOverride: str=None, certificateOverride: str=None, cacheOverride: ProjectCache=None, serviceRoleOverride: str=None, privilegedModeOverride: WrapperBoolean=None, timeoutInMinutesOverride: int=None, queuedTimeoutInMinutesOverride: int=None, idempotencyToken: str=None, logsConfigOverride: LogsConfig=None, registryCredentialOverride: RegistryCredential=None, imagePullCredentialsTypeOverride: str=None) -> StartBuildOutput:
        pass

    def stop_build(self, id: str) -> StopBuildOutput:
        pass

    def update_project(self, name: str, description: str=None, source: ProjectSource=None, secondarySources: List[ProjectSource]=None, artifacts: ProjectArtifacts=None, secondaryArtifacts: List[ProjectArtifacts]=None, cache: ProjectCache=None, environment: ProjectEnvironment=None, serviceRole: str=None, timeoutInMinutes: int=None, queuedTimeoutInMinutes: int=None, encryptionKey: str=None, tags: List[Tag]=None, vpcConfig: VpcConfig=None, badgeEnabled: WrapperBoolean=None, logsConfig: LogsConfig=None) -> UpdateProjectOutput:
        pass

    def update_webhook(self, projectName: str, branchFilter: str=None, rotateSecret: Boolean=None) -> UpdateWebhookOutput:
        pass


class CodeCommit(BaseClient):
    class BatchGetRepositoriesInput(Mapping):
        pass

    class BatchGetRepositoriesOutput(Mapping):
        pass

    class RepositoryName(object):
        pass

    class CreateBranchInput(Mapping):
        pass

    class CreatePullRequestInput(Mapping):
        pass

    class CreatePullRequestOutput(Mapping):
        pass

    class Target(Mapping):
        pass

    class CreateRepositoryInput(Mapping):
        pass

    class CreateRepositoryOutput(Mapping):
        pass

    class DeleteBranchInput(Mapping):
        pass

    class DeleteBranchOutput(Mapping):
        pass

    class DeleteCommentContentInput(Mapping):
        pass

    class DeleteCommentContentOutput(Mapping):
        pass

    class DeleteFileInput(Mapping):
        pass

    class DeleteFileOutput(Mapping):
        pass

    class KeepEmptyFolders(object):
        pass

    class DeleteRepositoryInput(Mapping):
        pass

    class DeleteRepositoryOutput(Mapping):
        pass

    class DescribePullRequestEventsInput(Mapping):
        pass

    class DescribePullRequestEventsOutput(Mapping):
        pass

    class GetBlobInput(Mapping):
        pass

    class GetBlobOutput(Mapping):
        pass

    class GetBranchInput(Mapping):
        pass

    class GetBranchOutput(Mapping):
        pass

    class GetCommentInput(Mapping):
        pass

    class GetCommentOutput(Mapping):
        pass

    class GetCommentsForComparedCommitInput(Mapping):
        pass

    class GetCommentsForComparedCommitOutput(Mapping):
        pass

    class GetCommentsForPullRequestInput(Mapping):
        pass

    class GetCommentsForPullRequestOutput(Mapping):
        pass

    class GetCommitInput(Mapping):
        pass

    class GetCommitOutput(Mapping):
        pass

    class GetDifferencesInput(Mapping):
        pass

    class GetDifferencesOutput(Mapping):
        pass

    class GetFileInput(Mapping):
        pass

    class GetFileOutput(Mapping):
        pass

    class GetFolderInput(Mapping):
        pass

    class GetFolderOutput(Mapping):
        pass

    class GetMergeConflictsInput(Mapping):
        pass

    class GetMergeConflictsOutput(Mapping):
        pass

    class GetPullRequestInput(Mapping):
        pass

    class GetPullRequestOutput(Mapping):
        pass

    class GetRepositoryInput(Mapping):
        pass

    class GetRepositoryOutput(Mapping):
        pass

    class GetRepositoryTriggersInput(Mapping):
        pass

    class GetRepositoryTriggersOutput(Mapping):
        pass

    class ListBranchesInput(Mapping):
        pass

    class ListBranchesOutput(Mapping):
        pass

    class ListPullRequestsInput(Mapping):
        pass

    class ListPullRequestsOutput(Mapping):
        pass

    class ListRepositoriesInput(Mapping):
        pass

    class ListRepositoriesOutput(Mapping):
        pass

    class MergePullRequestByFastForwardInput(Mapping):
        pass

    class MergePullRequestByFastForwardOutput(Mapping):
        pass

    class PostCommentForComparedCommitInput(Mapping):
        pass

    class PostCommentForComparedCommitOutput(Mapping):
        pass

    class Location(Mapping):
        pass

    class PostCommentForPullRequestInput(Mapping):
        pass

    class PostCommentForPullRequestOutput(Mapping):
        pass

    class PostCommentReplyInput(Mapping):
        pass

    class PostCommentReplyOutput(Mapping):
        pass

    class PutFileInput(Mapping):
        pass

    class PutFileOutput(Mapping):
        pass

    class FileContent(object):
        pass

    class PutRepositoryTriggersInput(Mapping):
        pass

    class PutRepositoryTriggersOutput(Mapping):
        pass

    class RepositoryTrigger(Mapping):
        pass

    class TestRepositoryTriggersInput(Mapping):
        pass

    class TestRepositoryTriggersOutput(Mapping):
        pass

    class UpdateCommentInput(Mapping):
        pass

    class UpdateCommentOutput(Mapping):
        pass

    class UpdateDefaultBranchInput(Mapping):
        pass

    class UpdatePullRequestDescriptionInput(Mapping):
        pass

    class UpdatePullRequestDescriptionOutput(Mapping):
        pass

    class UpdatePullRequestStatusInput(Mapping):
        pass

    class UpdatePullRequestStatusOutput(Mapping):
        pass

    class UpdatePullRequestTitleInput(Mapping):
        pass

    class UpdatePullRequestTitleOutput(Mapping):
        pass

    class UpdateRepositoryDescriptionInput(Mapping):
        pass

    class UpdateRepositoryNameInput(Mapping):
        pass

    def batch_get_repositories(self, repositoryNames: List[RepositoryName]) -> BatchGetRepositoriesOutput:
        pass

    def create_branch(self, commitId: str, branchName: str, repositoryName: str):
        pass

    def create_pull_request(self, targets: List[Target], title: str, description: str=None, clientRequestToken: str=None) -> CreatePullRequestOutput:
        pass

    def create_repository(self, repositoryName: str, repositoryDescription: str=None) -> CreateRepositoryOutput:
        pass

    def delete_branch(self, branchName: str, repositoryName: str) -> DeleteBranchOutput:
        pass

    def delete_comment_content(self, commentId: str) -> DeleteCommentContentOutput:
        pass

    def delete_file(self, parentCommitId: str, filePath: str, branchName: str, repositoryName: str, keepEmptyFolders: KeepEmptyFolders=None, commitMessage: str=None, name: str=None, email: str=None) -> DeleteFileOutput:
        pass

    def delete_repository(self, repositoryName: str) -> DeleteRepositoryOutput:
        pass

    def describe_pull_request_events(self, pullRequestId: str, pullRequestEventType: str=None, actorArn: str=None, nextToken: str=None, maxResults: int=None) -> DescribePullRequestEventsOutput:
        pass

    def get_blob(self, blobId: str, repositoryName: str) -> GetBlobOutput:
        pass

    def get_branch(self, repositoryName: str=None, branchName: str=None) -> GetBranchOutput:
        pass

    def get_comment(self, commentId: str) -> GetCommentOutput:
        pass

    def get_comments_for_compared_commit(self, afterCommitId: str, repositoryName: str, beforeCommitId: str=None, nextToken: str=None, maxResults: int=None) -> GetCommentsForComparedCommitOutput:
        pass

    def get_comments_for_pull_request(self, pullRequestId: str, repositoryName: str=None, beforeCommitId: str=None, afterCommitId: str=None, nextToken: str=None, maxResults: int=None) -> GetCommentsForPullRequestOutput:
        pass

    def get_commit(self, commitId: str, repositoryName: str) -> GetCommitOutput:
        pass

    def get_differences(self, afterCommitSpecifier: str, repositoryName: str, beforeCommitSpecifier: str=None, beforePath: str=None, afterPath: str=None, MaxResults: int=None, NextToken: str=None) -> GetDifferencesOutput:
        pass

    def get_file(self, filePath: str, repositoryName: str, commitSpecifier: str=None) -> GetFileOutput:
        pass

    def get_folder(self, folderPath: str, repositoryName: str, commitSpecifier: str=None) -> GetFolderOutput:
        pass

    def get_merge_conflicts(self, mergeOption: str, sourceCommitSpecifier: str, destinationCommitSpecifier: str, repositoryName: str) -> GetMergeConflictsOutput:
        pass

    def get_pull_request(self, pullRequestId: str) -> GetPullRequestOutput:
        pass

    def get_repository(self, repositoryName: str) -> GetRepositoryOutput:
        pass

    def get_repository_triggers(self, repositoryName: str) -> GetRepositoryTriggersOutput:
        pass

    def list_branches(self, repositoryName: str, nextToken: str=None) -> ListBranchesOutput:
        pass

    def list_pull_requests(self, repositoryName: str, authorArn: str=None, pullRequestStatus: str=None, nextToken: str=None, maxResults: int=None) -> ListPullRequestsOutput:
        pass

    def list_repositories(self, nextToken: str=None, sortBy: str=None, order: str=None) -> ListRepositoriesOutput:
        pass

    def merge_pull_request_by_fast_forward(self, repositoryName: str, pullRequestId: str, sourceCommitId: str=None) -> MergePullRequestByFastForwardOutput:
        pass

    def post_comment_for_compared_commit(self, content: str, afterCommitId: str, repositoryName: str, beforeCommitId: str=None, location: Location=None, clientRequestToken: str=None) -> PostCommentForComparedCommitOutput:
        pass

    def post_comment_for_pull_request(self, content: str, afterCommitId: str, beforeCommitId: str, repositoryName: str, pullRequestId: str, location: Location=None, clientRequestToken: str=None) -> PostCommentForPullRequestOutput:
        pass

    def post_comment_reply(self, content: str, inReplyTo: str, clientRequestToken: str=None) -> PostCommentReplyOutput:
        pass

    def put_file(self, filePath: str, fileContent: FileContent, branchName: str, repositoryName: str, fileMode: str=None, parentCommitId: str=None, commitMessage: str=None, name: str=None, email: str=None) -> PutFileOutput:
        pass

    def put_repository_triggers(self, triggers: List[RepositoryTrigger], repositoryName: str) -> PutRepositoryTriggersOutput:
        pass

    def test_repository_triggers(self, triggers: List[RepositoryTrigger], repositoryName: str) -> TestRepositoryTriggersOutput:
        pass

    def update_comment(self, content: str, commentId: str) -> UpdateCommentOutput:
        pass

    def update_default_branch(self, defaultBranchName: str, repositoryName: str):
        pass

    def update_pull_request_description(self, description: str, pullRequestId: str) -> UpdatePullRequestDescriptionOutput:
        pass

    def update_pull_request_status(self, pullRequestStatus: str, pullRequestId: str) -> UpdatePullRequestStatusOutput:
        pass

    def update_pull_request_title(self, title: str, pullRequestId: str) -> UpdatePullRequestTitleOutput:
        pass

    def update_repository_description(self, repositoryName: str, repositoryDescription: str=None):
        pass

    def update_repository_name(self, newName: str, oldName: str):
        pass


class CodeDeploy(BaseClient):
    class AddTagsToOnPremisesInstancesInput(Mapping):
        pass

    class Tag(Mapping):
        pass

    class InstanceName(object):
        pass

    class BatchGetApplicationRevisionsInput(Mapping):
        pass

    class BatchGetApplicationRevisionsOutput(Mapping):
        pass

    class RevisionLocation(Mapping):
        pass

    class BatchGetApplicationsInput(Mapping):
        pass

    class BatchGetApplicationsOutput(Mapping):
        pass

    class ApplicationName(object):
        pass

    class BatchGetDeploymentGroupsInput(Mapping):
        pass

    class BatchGetDeploymentGroupsOutput(Mapping):
        pass

    class DeploymentGroupName(object):
        pass

    class BatchGetDeploymentInstancesInput(Mapping):
        pass

    class BatchGetDeploymentInstancesOutput(Mapping):
        pass

    class InstanceId(object):
        pass

    class BatchGetDeploymentTargetsInput(Mapping):
        pass

    class BatchGetDeploymentTargetsOutput(Mapping):
        pass

    class TargetId(object):
        pass

    class BatchGetDeploymentsInput(Mapping):
        pass

    class BatchGetDeploymentsOutput(Mapping):
        pass

    class DeploymentId(object):
        pass

    class BatchGetOnPremisesInstancesInput(Mapping):
        pass

    class BatchGetOnPremisesInstancesOutput(Mapping):
        pass

    class ContinueDeploymentInput(Mapping):
        pass

    class CreateApplicationInput(Mapping):
        pass

    class CreateApplicationOutput(Mapping):
        pass

    class CreateDeploymentInput(Mapping):
        pass

    class CreateDeploymentOutput(Mapping):
        pass

    class Boolean(object):
        pass

    class TargetInstances(Mapping):
        pass

    class AutoRollbackConfiguration(Mapping):
        pass

    class CreateDeploymentConfigInput(Mapping):
        pass

    class CreateDeploymentConfigOutput(Mapping):
        pass

    class MinimumHealthyHosts(Mapping):
        pass

    class TrafficRoutingConfig(Mapping):
        pass

    class CreateDeploymentGroupInput(Mapping):
        pass

    class CreateDeploymentGroupOutput(Mapping):
        pass

    class EC2TagFilter(Mapping):
        pass

    class TagFilter(Mapping):
        pass

    class AutoScalingGroupName(object):
        pass

    class TriggerConfig(Mapping):
        pass

    class AlarmConfiguration(Mapping):
        pass

    class DeploymentStyle(Mapping):
        pass

    class BlueGreenDeploymentConfiguration(Mapping):
        pass

    class LoadBalancerInfo(Mapping):
        pass

    class EC2TagSet(Mapping):
        pass

    class ECSService(Mapping):
        pass

    class OnPremisesTagSet(Mapping):
        pass

    class DeleteApplicationInput(Mapping):
        pass

    class DeleteDeploymentConfigInput(Mapping):
        pass

    class DeleteDeploymentGroupInput(Mapping):
        pass

    class DeleteDeploymentGroupOutput(Mapping):
        pass

    class DeleteGitHubAccountTokenInput(Mapping):
        pass

    class DeleteGitHubAccountTokenOutput(Mapping):
        pass

    class DeregisterOnPremisesInstanceInput(Mapping):
        pass

    class GetApplicationInput(Mapping):
        pass

    class GetApplicationOutput(Mapping):
        pass

    class GetApplicationRevisionInput(Mapping):
        pass

    class GetApplicationRevisionOutput(Mapping):
        pass

    class GetDeploymentInput(Mapping):
        pass

    class GetDeploymentOutput(Mapping):
        pass

    class GetDeploymentConfigInput(Mapping):
        pass

    class GetDeploymentConfigOutput(Mapping):
        pass

    class GetDeploymentGroupInput(Mapping):
        pass

    class GetDeploymentGroupOutput(Mapping):
        pass

    class GetDeploymentInstanceInput(Mapping):
        pass

    class GetDeploymentInstanceOutput(Mapping):
        pass

    class GetDeploymentTargetInput(Mapping):
        pass

    class GetDeploymentTargetOutput(Mapping):
        pass

    class GetOnPremisesInstanceInput(Mapping):
        pass

    class GetOnPremisesInstanceOutput(Mapping):
        pass

    class ListApplicationRevisionsInput(Mapping):
        pass

    class ListApplicationRevisionsOutput(Mapping):
        pass

    class ListApplicationsInput(Mapping):
        pass

    class ListApplicationsOutput(Mapping):
        pass

    class ListDeploymentConfigsInput(Mapping):
        pass

    class ListDeploymentConfigsOutput(Mapping):
        pass

    class ListDeploymentGroupsInput(Mapping):
        pass

    class ListDeploymentGroupsOutput(Mapping):
        pass

    class ListDeploymentInstancesInput(Mapping):
        pass

    class ListDeploymentInstancesOutput(Mapping):
        pass

    class InstanceStatus(object):
        pass

    class InstanceType(object):
        pass

    class ListDeploymentTargetsInput(Mapping):
        pass

    class ListDeploymentTargetsOutput(Mapping):
        pass

    class TargetFilters(object):
        pass

    class ListDeploymentsInput(Mapping):
        pass

    class ListDeploymentsOutput(Mapping):
        pass

    class DeploymentStatus(object):
        pass

    class TimeRange(Mapping):
        pass

    class ListGitHubAccountTokenNamesInput(Mapping):
        pass

    class ListGitHubAccountTokenNamesOutput(Mapping):
        pass

    class ListOnPremisesInstancesInput(Mapping):
        pass

    class ListOnPremisesInstancesOutput(Mapping):
        pass

    class PutLifecycleEventHookExecutionStatusInput(Mapping):
        pass

    class PutLifecycleEventHookExecutionStatusOutput(Mapping):
        pass

    class RegisterApplicationRevisionInput(Mapping):
        pass

    class RegisterOnPremisesInstanceInput(Mapping):
        pass

    class RemoveTagsFromOnPremisesInstancesInput(Mapping):
        pass

    class SkipWaitTimeForInstanceTerminationInput(Mapping):
        pass

    class StopDeploymentInput(Mapping):
        pass

    class StopDeploymentOutput(Mapping):
        pass

    class NullableBoolean(object):
        pass

    class UpdateApplicationInput(Mapping):
        pass

    class UpdateDeploymentGroupInput(Mapping):
        pass

    class UpdateDeploymentGroupOutput(Mapping):
        pass

    def add_tags_to_on_premises_instances(self, instanceNames: List[InstanceName], tags: List[Tag]):
        pass

    def batch_get_application_revisions(self, revisions: List[RevisionLocation], applicationName: str) -> BatchGetApplicationRevisionsOutput:
        pass

    def batch_get_applications(self, applicationNames: List[ApplicationName]) -> BatchGetApplicationsOutput:
        pass

    def batch_get_deployment_groups(self, deploymentGroupNames: List[DeploymentGroupName], applicationName: str) -> BatchGetDeploymentGroupsOutput:
        pass

    def batch_get_deployment_instances(self, instanceIds: List[InstanceId], deploymentId: str) -> BatchGetDeploymentInstancesOutput:
        pass

    def batch_get_deployment_targets(self, deploymentId: str=None, targetIds: List[TargetId]=None) -> BatchGetDeploymentTargetsOutput:
        pass

    def batch_get_deployments(self, deploymentIds: List[DeploymentId]) -> BatchGetDeploymentsOutput:
        pass

    def batch_get_on_premises_instances(self, instanceNames: List[InstanceName]) -> BatchGetOnPremisesInstancesOutput:
        pass

    def continue_deployment(self, deploymentId: str=None, deploymentWaitType: str=None):
        pass

    def create_application(self, applicationName: str, computePlatform: str=None) -> CreateApplicationOutput:
        pass

    def create_deployment(self, applicationName: str, deploymentGroupName: str=None, revision: RevisionLocation=None, deploymentConfigName: str=None, description: str=None, ignoreApplicationStopFailures: Boolean=None, targetInstances: TargetInstances=None, autoRollbackConfiguration: AutoRollbackConfiguration=None, updateOutdatedInstancesOnly: Boolean=None, fileExistsBehavior: str=None) -> CreateDeploymentOutput:
        pass

    def create_deployment_config(self, deploymentConfigName: str, minimumHealthyHosts: MinimumHealthyHosts=None, trafficRoutingConfig: TrafficRoutingConfig=None, computePlatform: str=None) -> CreateDeploymentConfigOutput:
        pass

    def create_deployment_group(self, serviceRoleArn: str, deploymentGroupName: str, applicationName: str, deploymentConfigName: str=None, ec2TagFilters: List[EC2TagFilter]=None, onPremisesInstanceTagFilters: List[TagFilter]=None, autoScalingGroups: List[AutoScalingGroupName]=None, triggerConfigurations: List[TriggerConfig]=None, alarmConfiguration: AlarmConfiguration=None, autoRollbackConfiguration: AutoRollbackConfiguration=None, deploymentStyle: DeploymentStyle=None, blueGreenDeploymentConfiguration: BlueGreenDeploymentConfiguration=None, loadBalancerInfo: LoadBalancerInfo=None, ec2TagSet: EC2TagSet=None, ecsServices: List[ECSService]=None, onPremisesTagSet: OnPremisesTagSet=None) -> CreateDeploymentGroupOutput:
        pass

    def delete_application(self, applicationName: str):
        pass

    def delete_deployment_config(self, deploymentConfigName: str):
        pass

    def delete_deployment_group(self, deploymentGroupName: str, applicationName: str) -> DeleteDeploymentGroupOutput:
        pass

    def delete_git_hub_account_token(self, tokenName: str=None) -> DeleteGitHubAccountTokenOutput:
        pass

    def deregister_on_premises_instance(self, instanceName: str):
        pass

    def get_application(self, applicationName: str) -> GetApplicationOutput:
        pass

    def get_application_revision(self, revision: RevisionLocation, applicationName: str) -> GetApplicationRevisionOutput:
        pass

    def get_deployment(self, deploymentId: str) -> GetDeploymentOutput:
        pass

    def get_deployment_config(self, deploymentConfigName: str) -> GetDeploymentConfigOutput:
        pass

    def get_deployment_group(self, deploymentGroupName: str, applicationName: str) -> GetDeploymentGroupOutput:
        pass

    def get_deployment_instance(self, instanceId: str, deploymentId: str) -> GetDeploymentInstanceOutput:
        pass

    def get_deployment_target(self, deploymentId: str=None, targetId: str=None) -> GetDeploymentTargetOutput:
        pass

    def get_on_premises_instance(self, instanceName: str) -> GetOnPremisesInstanceOutput:
        pass

    def list_application_revisions(self, applicationName: str, sortBy: str=None, sortOrder: str=None, s3Bucket: str=None, s3KeyPrefix: str=None, deployed: str=None, nextToken: str=None) -> ListApplicationRevisionsOutput:
        pass

    def list_applications(self, nextToken: str=None) -> ListApplicationsOutput:
        pass

    def list_deployment_configs(self, nextToken: str=None) -> ListDeploymentConfigsOutput:
        pass

    def list_deployment_groups(self, applicationName: str, nextToken: str=None) -> ListDeploymentGroupsOutput:
        pass

    def list_deployment_instances(self, deploymentId: str, nextToken: str=None, instanceStatusFilter: List[InstanceStatus]=None, instanceTypeFilter: List[InstanceType]=None) -> ListDeploymentInstancesOutput:
        pass

    def list_deployment_targets(self, deploymentId: str=None, nextToken: str=None, targetFilters: TargetFilters=None) -> ListDeploymentTargetsOutput:
        pass

    def list_deployments(self, applicationName: str=None, deploymentGroupName: str=None, includeOnlyStatuses: List[DeploymentStatus]=None, createTimeRange: TimeRange=None, nextToken: str=None) -> ListDeploymentsOutput:
        pass

    def list_git_hub_account_token_names(self, nextToken: str=None) -> ListGitHubAccountTokenNamesOutput:
        pass

    def list_on_premises_instances(self, registrationStatus: str=None, tagFilters: List[TagFilter]=None, nextToken: str=None) -> ListOnPremisesInstancesOutput:
        pass

    def put_lifecycle_event_hook_execution_status(self, deploymentId: str=None, lifecycleEventHookExecutionId: str=None, status: str=None) -> PutLifecycleEventHookExecutionStatusOutput:
        pass

    def register_application_revision(self, revision: RevisionLocation, applicationName: str, description: str=None):
        pass

    def register_on_premises_instance(self, instanceName: str, iamSessionArn: str=None, iamUserArn: str=None):
        pass

    def remove_tags_from_on_premises_instances(self, instanceNames: List[InstanceName], tags: List[Tag]):
        pass

    def skip_wait_time_for_instance_termination(self, deploymentId: str=None):
        pass

    def stop_deployment(self, deploymentId: str, autoRollbackEnabled: NullableBoolean=None) -> StopDeploymentOutput:
        pass

    def update_application(self, applicationName: str=None, newApplicationName: str=None):
        pass

    def update_deployment_group(self, currentDeploymentGroupName: str, applicationName: str, newDeploymentGroupName: str=None, deploymentConfigName: str=None, ec2TagFilters: List[EC2TagFilter]=None, onPremisesInstanceTagFilters: List[TagFilter]=None, autoScalingGroups: List[AutoScalingGroupName]=None, serviceRoleArn: str=None, triggerConfigurations: List[TriggerConfig]=None, alarmConfiguration: AlarmConfiguration=None, autoRollbackConfiguration: AutoRollbackConfiguration=None, deploymentStyle: DeploymentStyle=None, blueGreenDeploymentConfiguration: BlueGreenDeploymentConfiguration=None, loadBalancerInfo: LoadBalancerInfo=None, ec2TagSet: EC2TagSet=None, ecsServices: List[ECSService]=None, onPremisesTagSet: OnPremisesTagSet=None) -> UpdateDeploymentGroupOutput:
        pass


class CodePipeline(BaseClient):
    class AcknowledgeJobInput(Mapping):
        pass

    class AcknowledgeJobOutput(Mapping):
        pass

    class AcknowledgeThirdPartyJobInput(Mapping):
        pass

    class AcknowledgeThirdPartyJobOutput(Mapping):
        pass

    class CreateCustomActionTypeInput(Mapping):
        pass

    class CreateCustomActionTypeOutput(Mapping):
        pass

    class ActionTypeSettings(Mapping):
        pass

    class ActionConfigurationProperty(Mapping):
        pass

    class ArtifactDetails(Mapping):
        pass

    class CreatePipelineInput(Mapping):
        pass

    class CreatePipelineOutput(Mapping):
        pass

    class PipelineDeclaration(Mapping):
        pass

    class DeleteCustomActionTypeInput(Mapping):
        pass

    class DeletePipelineInput(Mapping):
        pass

    class DeleteWebhookInput(Mapping):
        pass

    class DeleteWebhookOutput(Mapping):
        pass

    class DeregisterWebhookWithThirdPartyInput(Mapping):
        pass

    class DeregisterWebhookWithThirdPartyOutput(Mapping):
        pass

    class DisableStageTransitionInput(Mapping):
        pass

    class EnableStageTransitionInput(Mapping):
        pass

    class GetJobDetailsInput(Mapping):
        pass

    class GetJobDetailsOutput(Mapping):
        pass

    class GetPipelineInput(Mapping):
        pass

    class GetPipelineOutput(Mapping):
        pass

    class GetPipelineExecutionInput(Mapping):
        pass

    class GetPipelineExecutionOutput(Mapping):
        pass

    class GetPipelineStateInput(Mapping):
        pass

    class GetPipelineStateOutput(Mapping):
        pass

    class GetThirdPartyJobDetailsInput(Mapping):
        pass

    class GetThirdPartyJobDetailsOutput(Mapping):
        pass

    class ListActionTypesInput(Mapping):
        pass

    class ListActionTypesOutput(Mapping):
        pass

    class ListPipelineExecutionsInput(Mapping):
        pass

    class ListPipelineExecutionsOutput(Mapping):
        pass

    class ListPipelinesInput(Mapping):
        pass

    class ListPipelinesOutput(Mapping):
        pass

    class ListWebhooksInput(Mapping):
        pass

    class ListWebhooksOutput(Mapping):
        pass

    class PollForJobsInput(Mapping):
        pass

    class PollForJobsOutput(Mapping):
        pass

    class ActionTypeId(Mapping):
        pass

    class QueryParamMap(object):
        pass

    class PollForThirdPartyJobsInput(Mapping):
        pass

    class PollForThirdPartyJobsOutput(Mapping):
        pass

    class PutActionRevisionInput(Mapping):
        pass

    class PutActionRevisionOutput(Mapping):
        pass

    class ActionRevision(Mapping):
        pass

    class PutApprovalResultInput(Mapping):
        pass

    class PutApprovalResultOutput(Mapping):
        pass

    class ApprovalResult(Mapping):
        pass

    class PutJobFailureResultInput(Mapping):
        pass

    class FailureDetails(Mapping):
        pass

    class PutJobSuccessResultInput(Mapping):
        pass

    class CurrentRevision(Mapping):
        pass

    class ExecutionDetails(Mapping):
        pass

    class PutThirdPartyJobFailureResultInput(Mapping):
        pass

    class PutThirdPartyJobSuccessResultInput(Mapping):
        pass

    class PutWebhookInput(Mapping):
        pass

    class PutWebhookOutput(Mapping):
        pass

    class WebhookDefinition(Mapping):
        pass

    class RegisterWebhookWithThirdPartyInput(Mapping):
        pass

    class RegisterWebhookWithThirdPartyOutput(Mapping):
        pass

    class RetryStageExecutionInput(Mapping):
        pass

    class RetryStageExecutionOutput(Mapping):
        pass

    class StartPipelineExecutionInput(Mapping):
        pass

    class StartPipelineExecutionOutput(Mapping):
        pass

    class UpdatePipelineInput(Mapping):
        pass

    class UpdatePipelineOutput(Mapping):
        pass

    def acknowledge_job(self, nonce: str, jobId: str) -> AcknowledgeJobOutput:
        pass

    def acknowledge_third_party_job(self, clientToken: str, nonce: str, jobId: str) -> AcknowledgeThirdPartyJobOutput:
        pass

    def create_custom_action_type(self, outputArtifactDetails: ArtifactDetails, inputArtifactDetails: ArtifactDetails, version: str, provider: str, category: str, settings: ActionTypeSettings=None, configurationProperties: List[ActionConfigurationProperty]=None) -> CreateCustomActionTypeOutput:
        pass

    def create_pipeline(self, pipeline: PipelineDeclaration) -> CreatePipelineOutput:
        pass

    def delete_custom_action_type(self, version: str, provider: str, category: str):
        pass

    def delete_pipeline(self, name: str):
        pass

    def delete_webhook(self, name: str) -> DeleteWebhookOutput:
        pass

    def deregister_webhook_with_third_party(self, webhookName: str=None) -> DeregisterWebhookWithThirdPartyOutput:
        pass

    def disable_stage_transition(self, reason: str, transitionType: str, stageName: str, pipelineName: str):
        pass

    def enable_stage_transition(self, transitionType: str, stageName: str, pipelineName: str):
        pass

    def get_job_details(self, jobId: str) -> GetJobDetailsOutput:
        pass

    def get_pipeline(self, name: str, version: int=None) -> GetPipelineOutput:
        pass

    def get_pipeline_execution(self, pipelineExecutionId: str, pipelineName: str) -> GetPipelineExecutionOutput:
        pass

    def get_pipeline_state(self, name: str) -> GetPipelineStateOutput:
        pass

    def get_third_party_job_details(self, clientToken: str, jobId: str) -> GetThirdPartyJobDetailsOutput:
        pass

    def list_action_types(self, actionOwnerFilter: str=None, nextToken: str=None) -> ListActionTypesOutput:
        pass

    def list_pipeline_executions(self, pipelineName: str, maxResults: int=None, nextToken: str=None) -> ListPipelineExecutionsOutput:
        pass

    def list_pipelines(self, nextToken: str=None) -> ListPipelinesOutput:
        pass

    def list_webhooks(self, NextToken: str=None, MaxResults: int=None) -> ListWebhooksOutput:
        pass

    def poll_for_jobs(self, actionTypeId: ActionTypeId, maxBatchSize: int=None, queryParam: QueryParamMap=None) -> PollForJobsOutput:
        pass

    def poll_for_third_party_jobs(self, actionTypeId: ActionTypeId, maxBatchSize: int=None) -> PollForThirdPartyJobsOutput:
        pass

    def put_action_revision(self, actionRevision: ActionRevision, actionName: str, stageName: str, pipelineName: str) -> PutActionRevisionOutput:
        pass

    def put_approval_result(self, token: str, result: ApprovalResult, actionName: str, stageName: str, pipelineName: str) -> PutApprovalResultOutput:
        pass

    def put_job_failure_result(self, failureDetails: FailureDetails, jobId: str):
        pass

    def put_job_success_result(self, jobId: str, currentRevision: CurrentRevision=None, continuationToken: str=None, executionDetails: ExecutionDetails=None):
        pass

    def put_third_party_job_failure_result(self, failureDetails: FailureDetails, clientToken: str, jobId: str):
        pass

    def put_third_party_job_success_result(self, clientToken: str, jobId: str, currentRevision: CurrentRevision=None, continuationToken: str=None, executionDetails: ExecutionDetails=None):
        pass

    def put_webhook(self, webhook: WebhookDefinition) -> PutWebhookOutput:
        pass

    def register_webhook_with_third_party(self, webhookName: str=None) -> RegisterWebhookWithThirdPartyOutput:
        pass

    def retry_stage_execution(self, retryMode: str, pipelineExecutionId: str, stageName: str, pipelineName: str) -> RetryStageExecutionOutput:
        pass

    def start_pipeline_execution(self, name: str, clientRequestToken: str=None) -> StartPipelineExecutionOutput:
        pass

    def update_pipeline(self, pipeline: PipelineDeclaration) -> UpdatePipelineOutput:
        pass


class CodeStar(BaseClient):
    class AssociateTeamMemberRequest(Mapping):
        pass

    class AssociateTeamMemberResult(Mapping):
        pass

    class RemoteAccessAllowed(object):
        pass

    class CreateProjectRequest(Mapping):
        pass

    class CreateProjectResult(Mapping):
        pass

    class Code(Mapping):
        pass

    class Toolchain(Mapping):
        pass

    class Tags(object):
        pass

    class CreateUserProfileRequest(Mapping):
        pass

    class CreateUserProfileResult(Mapping):
        pass

    class DeleteProjectRequest(Mapping):
        pass

    class DeleteProjectResult(Mapping):
        pass

    class DeleteStack(object):
        pass

    class DeleteUserProfileRequest(Mapping):
        pass

    class DeleteUserProfileResult(Mapping):
        pass

    class DescribeProjectRequest(Mapping):
        pass

    class DescribeProjectResult(Mapping):
        pass

    class DescribeUserProfileRequest(Mapping):
        pass

    class DescribeUserProfileResult(Mapping):
        pass

    class DisassociateTeamMemberRequest(Mapping):
        pass

    class DisassociateTeamMemberResult(Mapping):
        pass

    class ListProjectsRequest(Mapping):
        pass

    class ListProjectsResult(Mapping):
        pass

    class ListResourcesRequest(Mapping):
        pass

    class ListResourcesResult(Mapping):
        pass

    class ListTagsForProjectRequest(Mapping):
        pass

    class ListTagsForProjectResult(Mapping):
        pass

    class ListTeamMembersRequest(Mapping):
        pass

    class ListTeamMembersResult(Mapping):
        pass

    class ListUserProfilesRequest(Mapping):
        pass

    class ListUserProfilesResult(Mapping):
        pass

    class TagProjectRequest(Mapping):
        pass

    class TagProjectResult(Mapping):
        pass

    class UntagProjectRequest(Mapping):
        pass

    class UntagProjectResult(Mapping):
        pass

    class TagKey(object):
        pass

    class UpdateProjectRequest(Mapping):
        pass

    class UpdateProjectResult(Mapping):
        pass

    class UpdateTeamMemberRequest(Mapping):
        pass

    class UpdateTeamMemberResult(Mapping):
        pass

    class UpdateUserProfileRequest(Mapping):
        pass

    class UpdateUserProfileResult(Mapping):
        pass

    def associate_team_member(self, projectRole: str, userArn: str, projectId: str, clientRequestToken: str=None, remoteAccessAllowed: RemoteAccessAllowed=None) -> AssociateTeamMemberResult:
        pass

    def create_project(self, id: str, name: str, description: str=None, clientRequestToken: str=None, sourceCode: List[Code]=None, toolchain: Toolchain=None, tags: Tags=None) -> CreateProjectResult:
        pass

    def create_user_profile(self, emailAddress: str, displayName: str, userArn: str, sshPublicKey: str=None) -> CreateUserProfileResult:
        pass

    def delete_project(self, id: str, clientRequestToken: str=None, deleteStack: DeleteStack=None) -> DeleteProjectResult:
        pass

    def delete_user_profile(self, userArn: str) -> DeleteUserProfileResult:
        pass

    def describe_project(self, id: str) -> DescribeProjectResult:
        pass

    def describe_user_profile(self, userArn: str) -> DescribeUserProfileResult:
        pass

    def disassociate_team_member(self, userArn: str, projectId: str) -> DisassociateTeamMemberResult:
        pass

    def list_projects(self, nextToken: str=None, maxResults: int=None) -> ListProjectsResult:
        pass

    def list_resources(self, projectId: str, nextToken: str=None, maxResults: int=None) -> ListResourcesResult:
        pass

    def list_tags_for_project(self, id: str, nextToken: str=None, maxResults: int=None) -> ListTagsForProjectResult:
        pass

    def list_team_members(self, projectId: str, nextToken: str=None, maxResults: int=None) -> ListTeamMembersResult:
        pass

    def list_user_profiles(self, nextToken: str=None, maxResults: int=None) -> ListUserProfilesResult:
        pass

    def tag_project(self, tags: Tags, id: str) -> TagProjectResult:
        pass

    def untag_project(self, tags: List[TagKey], id: str) -> UntagProjectResult:
        pass

    def update_project(self, id: str, name: str=None, description: str=None) -> UpdateProjectResult:
        pass

    def update_team_member(self, userArn: str, projectId: str, projectRole: str=None, remoteAccessAllowed: RemoteAccessAllowed=None) -> UpdateTeamMemberResult:
        pass

    def update_user_profile(self, userArn: str, displayName: str=None, emailAddress: str=None, sshPublicKey: str=None) -> UpdateUserProfileResult:
        pass


class CognitoIdentity(BaseClient):
    class CreateIdentityPoolInput(Mapping):
        pass

    class IdentityPool(Mapping):
        pass

    class IdentityPoolUnauthenticated(object):
        pass

    class IdentityProviders(object):
        pass

    class ARNString(object):
        pass

    class CognitoIdentityProvider(Mapping):
        pass

    class DeleteIdentitiesInput(Mapping):
        pass

    class DeleteIdentitiesResponse(Mapping):
        pass

    class IdentityId(object):
        pass

    class DeleteIdentityPoolInput(Mapping):
        pass

    class DescribeIdentityInput(Mapping):
        pass

    class IdentityDescription(Mapping):
        pass

    class DescribeIdentityPoolInput(Mapping):
        pass

    class GetCredentialsForIdentityInput(Mapping):
        pass

    class GetCredentialsForIdentityResponse(Mapping):
        pass

    class LoginsMap(object):
        pass

    class GetIdInput(Mapping):
        pass

    class GetIdResponse(Mapping):
        pass

    class GetIdentityPoolRolesInput(Mapping):
        pass

    class GetIdentityPoolRolesResponse(Mapping):
        pass

    class GetOpenIdTokenInput(Mapping):
        pass

    class GetOpenIdTokenResponse(Mapping):
        pass

    class GetOpenIdTokenForDeveloperIdentityInput(Mapping):
        pass

    class GetOpenIdTokenForDeveloperIdentityResponse(Mapping):
        pass

    class TokenDuration(object):
        pass

    class ListIdentitiesInput(Mapping):
        pass

    class ListIdentitiesResponse(Mapping):
        pass

    class HideDisabled(object):
        pass

    class ListIdentityPoolsInput(Mapping):
        pass

    class ListIdentityPoolsResponse(Mapping):
        pass

    class LookupDeveloperIdentityInput(Mapping):
        pass

    class LookupDeveloperIdentityResponse(Mapping):
        pass

    class MergeDeveloperIdentitiesInput(Mapping):
        pass

    class MergeDeveloperIdentitiesResponse(Mapping):
        pass

    class SetIdentityPoolRolesInput(Mapping):
        pass

    class RolesMap(object):
        pass

    class RoleMappingMap(object):
        pass

    class UnlinkDeveloperIdentityInput(Mapping):
        pass

    class UnlinkIdentityInput(Mapping):
        pass

    class IdentityProviderName(object):
        pass

    def create_identity_pool(self, AllowUnauthenticatedIdentities: IdentityPoolUnauthenticated, IdentityPoolName: str, SupportedLoginProviders: IdentityProviders=None, DeveloperProviderName: str=None, OpenIdConnectProviderARNs: List[ARNString]=None, CognitoIdentityProviders: List[CognitoIdentityProvider]=None, SamlProviderARNs: List[ARNString]=None) -> IdentityPool:
        pass

    def delete_identities(self, IdentityIdsToDelete: List[IdentityId]) -> DeleteIdentitiesResponse:
        pass

    def delete_identity_pool(self, IdentityPoolId: str):
        pass

    def describe_identity(self, IdentityId: str) -> IdentityDescription:
        pass

    def describe_identity_pool(self, IdentityPoolId: str) -> IdentityPool:
        pass

    def get_credentials_for_identity(self, IdentityId: str, Logins: LoginsMap=None, CustomRoleArn: str=None) -> GetCredentialsForIdentityResponse:
        pass

    def get_id(self, IdentityPoolId: str, AccountId: str=None, Logins: LoginsMap=None) -> GetIdResponse:
        pass

    def get_identity_pool_roles(self, IdentityPoolId: str) -> GetIdentityPoolRolesResponse:
        pass

    def get_open_id_token(self, IdentityId: str, Logins: LoginsMap=None) -> GetOpenIdTokenResponse:
        pass

    def get_open_id_token_for_developer_identity(self, Logins: LoginsMap, IdentityPoolId: str, IdentityId: str=None, TokenDuration: TokenDuration=None) -> GetOpenIdTokenForDeveloperIdentityResponse:
        pass

    def list_identities(self, MaxResults: int, IdentityPoolId: str, NextToken: str=None, HideDisabled: HideDisabled=None) -> ListIdentitiesResponse:
        pass

    def list_identity_pools(self, MaxResults: int, NextToken: str=None) -> ListIdentityPoolsResponse:
        pass

    def lookup_developer_identity(self, IdentityPoolId: str, IdentityId: str=None, DeveloperUserIdentifier: str=None, MaxResults: int=None, NextToken: str=None) -> LookupDeveloperIdentityResponse:
        pass

    def merge_developer_identities(self, IdentityPoolId: str, DeveloperProviderName: str, DestinationUserIdentifier: str, SourceUserIdentifier: str) -> MergeDeveloperIdentitiesResponse:
        pass

    def set_identity_pool_roles(self, Roles: RolesMap, IdentityPoolId: str, RoleMappings: RoleMappingMap=None):
        pass

    def unlink_developer_identity(self, DeveloperUserIdentifier: str, DeveloperProviderName: str, IdentityPoolId: str, IdentityId: str):
        pass

    def unlink_identity(self, LoginsToRemove: List[IdentityProviderName], Logins: LoginsMap, IdentityId: str):
        pass

    def update_identity_pool(self, AllowUnauthenticatedIdentities: IdentityPoolUnauthenticated, IdentityPoolName: str, IdentityPoolId: str, SupportedLoginProviders: IdentityProviders=None, DeveloperProviderName: str=None, OpenIdConnectProviderARNs: List[ARNString]=None, CognitoIdentityProviders: List[CognitoIdentityProvider]=None, SamlProviderARNs: List[ARNString]=None) -> IdentityPool:
        pass


class CognitoIdentityProvider(BaseClient):
    class AddCustomAttributesRequest(Mapping):
        pass

    class AddCustomAttributesResponse(Mapping):
        pass

    class SchemaAttributeType(Mapping):
        pass

    class AdminAddUserToGroupRequest(Mapping):
        pass

    class AdminConfirmSignUpRequest(Mapping):
        pass

    class AdminConfirmSignUpResponse(Mapping):
        pass

    class AdminCreateUserRequest(Mapping):
        pass

    class AdminCreateUserResponse(Mapping):
        pass

    class AttributeType(Mapping):
        pass

    class ForceAliasCreation(object):
        pass

    class DeliveryMediumType(object):
        pass

    class AdminDeleteUserRequest(Mapping):
        pass

    class AdminDeleteUserAttributesRequest(Mapping):
        pass

    class AdminDeleteUserAttributesResponse(Mapping):
        pass

    class AttributeNameType(object):
        pass

    class AdminDisableProviderForUserRequest(Mapping):
        pass

    class AdminDisableProviderForUserResponse(Mapping):
        pass

    class ProviderUserIdentifierType(Mapping):
        pass

    class AdminDisableUserRequest(Mapping):
        pass

    class AdminDisableUserResponse(Mapping):
        pass

    class AdminEnableUserRequest(Mapping):
        pass

    class AdminEnableUserResponse(Mapping):
        pass

    class AdminForgetDeviceRequest(Mapping):
        pass

    class AdminGetDeviceRequest(Mapping):
        pass

    class AdminGetDeviceResponse(Mapping):
        pass

    class AdminGetUserRequest(Mapping):
        pass

    class AdminGetUserResponse(Mapping):
        pass

    class AdminInitiateAuthRequest(Mapping):
        pass

    class AdminInitiateAuthResponse(Mapping):
        pass

    class AuthParametersType(object):
        pass

    class ClientMetadataType(object):
        pass

    class AnalyticsMetadataType(Mapping):
        pass

    class ContextDataType(Mapping):
        pass

    class AdminLinkProviderForUserRequest(Mapping):
        pass

    class AdminLinkProviderForUserResponse(Mapping):
        pass

    class AdminListDevicesRequest(Mapping):
        pass

    class AdminListDevicesResponse(Mapping):
        pass

    class AdminListGroupsForUserRequest(Mapping):
        pass

    class AdminListGroupsForUserResponse(Mapping):
        pass

    class AdminListUserAuthEventsRequest(Mapping):
        pass

    class AdminListUserAuthEventsResponse(Mapping):
        pass

    class AdminRemoveUserFromGroupRequest(Mapping):
        pass

    class AdminResetUserPasswordRequest(Mapping):
        pass

    class AdminResetUserPasswordResponse(Mapping):
        pass

    class AdminRespondToAuthChallengeRequest(Mapping):
        pass

    class AdminRespondToAuthChallengeResponse(Mapping):
        pass

    class ChallengeResponsesType(object):
        pass

    class AdminSetUserMFAPreferenceRequest(Mapping):
        pass

    class AdminSetUserMFAPreferenceResponse(Mapping):
        pass

    class SMSMfaSettingsType(Mapping):
        pass

    class SoftwareTokenMfaSettingsType(Mapping):
        pass

    class AdminSetUserSettingsRequest(Mapping):
        pass

    class AdminSetUserSettingsResponse(Mapping):
        pass

    class MFAOptionType(Mapping):
        pass

    class AdminUpdateAuthEventFeedbackRequest(Mapping):
        pass

    class AdminUpdateAuthEventFeedbackResponse(Mapping):
        pass

    class AdminUpdateDeviceStatusRequest(Mapping):
        pass

    class AdminUpdateDeviceStatusResponse(Mapping):
        pass

    class AdminUpdateUserAttributesRequest(Mapping):
        pass

    class AdminUpdateUserAttributesResponse(Mapping):
        pass

    class AdminUserGlobalSignOutRequest(Mapping):
        pass

    class AdminUserGlobalSignOutResponse(Mapping):
        pass

    class AssociateSoftwareTokenRequest(Mapping):
        pass

    class AssociateSoftwareTokenResponse(Mapping):
        pass

    class ChangePasswordRequest(Mapping):
        pass

    class ChangePasswordResponse(Mapping):
        pass

    class ConfirmDeviceRequest(Mapping):
        pass

    class ConfirmDeviceResponse(Mapping):
        pass

    class DeviceSecretVerifierConfigType(Mapping):
        pass

    class ConfirmForgotPasswordRequest(Mapping):
        pass

    class ConfirmForgotPasswordResponse(Mapping):
        pass

    class UserContextDataType(Mapping):
        pass

    class ConfirmSignUpRequest(Mapping):
        pass

    class ConfirmSignUpResponse(Mapping):
        pass

    class CreateGroupRequest(Mapping):
        pass

    class CreateGroupResponse(Mapping):
        pass

    class CreateIdentityProviderRequest(Mapping):
        pass

    class CreateIdentityProviderResponse(Mapping):
        pass

    class ProviderDetailsType(object):
        pass

    class AttributeMappingType(object):
        pass

    class IdpIdentifierType(object):
        pass

    class CreateResourceServerRequest(Mapping):
        pass

    class CreateResourceServerResponse(Mapping):
        pass

    class ResourceServerScopeType(Mapping):
        pass

    class CreateUserImportJobRequest(Mapping):
        pass

    class CreateUserImportJobResponse(Mapping):
        pass

    class CreateUserPoolRequest(Mapping):
        pass

    class CreateUserPoolResponse(Mapping):
        pass

    class UserPoolPolicyType(Mapping):
        pass

    class LambdaConfigType(Mapping):
        pass

    class VerifiedAttributeType(object):
        pass

    class AliasAttributeType(object):
        pass

    class UsernameAttributeType(object):
        pass

    class VerificationMessageTemplateType(Mapping):
        pass

    class DeviceConfigurationType(Mapping):
        pass

    class EmailConfigurationType(Mapping):
        pass

    class SmsConfigurationType(Mapping):
        pass

    class UserPoolTagsType(object):
        pass

    class AdminCreateUserConfigType(Mapping):
        pass

    class UserPoolAddOnsType(Mapping):
        pass

    class CreateUserPoolClientRequest(Mapping):
        pass

    class CreateUserPoolClientResponse(Mapping):
        pass

    class GenerateSecret(object):
        pass

    class ClientPermissionType(object):
        pass

    class ExplicitAuthFlowsType(object):
        pass

    class ProviderNameType(object):
        pass

    class RedirectUrlType(object):
        pass

    class OAuthFlowType(object):
        pass

    class ScopeType(object):
        pass

    class BooleanType(object):
        pass

    class AnalyticsConfigurationType(Mapping):
        pass

    class CreateUserPoolDomainRequest(Mapping):
        pass

    class CreateUserPoolDomainResponse(Mapping):
        pass

    class CustomDomainConfigType(Mapping):
        pass

    class DeleteGroupRequest(Mapping):
        pass

    class DeleteIdentityProviderRequest(Mapping):
        pass

    class DeleteResourceServerRequest(Mapping):
        pass

    class DeleteUserRequest(Mapping):
        pass

    class DeleteUserAttributesRequest(Mapping):
        pass

    class DeleteUserAttributesResponse(Mapping):
        pass

    class DeleteUserPoolRequest(Mapping):
        pass

    class DeleteUserPoolClientRequest(Mapping):
        pass

    class DeleteUserPoolDomainRequest(Mapping):
        pass

    class DeleteUserPoolDomainResponse(Mapping):
        pass

    class DescribeIdentityProviderRequest(Mapping):
        pass

    class DescribeIdentityProviderResponse(Mapping):
        pass

    class DescribeResourceServerRequest(Mapping):
        pass

    class DescribeResourceServerResponse(Mapping):
        pass

    class DescribeRiskConfigurationRequest(Mapping):
        pass

    class DescribeRiskConfigurationResponse(Mapping):
        pass

    class DescribeUserImportJobRequest(Mapping):
        pass

    class DescribeUserImportJobResponse(Mapping):
        pass

    class DescribeUserPoolRequest(Mapping):
        pass

    class DescribeUserPoolResponse(Mapping):
        pass

    class DescribeUserPoolClientRequest(Mapping):
        pass

    class DescribeUserPoolClientResponse(Mapping):
        pass

    class DescribeUserPoolDomainRequest(Mapping):
        pass

    class DescribeUserPoolDomainResponse(Mapping):
        pass

    class ForgetDeviceRequest(Mapping):
        pass

    class ForgotPasswordRequest(Mapping):
        pass

    class ForgotPasswordResponse(Mapping):
        pass

    class GetCSVHeaderRequest(Mapping):
        pass

    class GetCSVHeaderResponse(Mapping):
        pass

    class GetDeviceRequest(Mapping):
        pass

    class GetDeviceResponse(Mapping):
        pass

    class GetGroupRequest(Mapping):
        pass

    class GetGroupResponse(Mapping):
        pass

    class GetIdentityProviderByIdentifierRequest(Mapping):
        pass

    class GetIdentityProviderByIdentifierResponse(Mapping):
        pass

    class GetSigningCertificateRequest(Mapping):
        pass

    class GetSigningCertificateResponse(Mapping):
        pass

    class GetUICustomizationRequest(Mapping):
        pass

    class GetUICustomizationResponse(Mapping):
        pass

    class GetUserRequest(Mapping):
        pass

    class GetUserResponse(Mapping):
        pass

    class GetUserAttributeVerificationCodeRequest(Mapping):
        pass

    class GetUserAttributeVerificationCodeResponse(Mapping):
        pass

    class GetUserPoolMfaConfigRequest(Mapping):
        pass

    class GetUserPoolMfaConfigResponse(Mapping):
        pass

    class GlobalSignOutRequest(Mapping):
        pass

    class GlobalSignOutResponse(Mapping):
        pass

    class InitiateAuthRequest(Mapping):
        pass

    class InitiateAuthResponse(Mapping):
        pass

    class ListDevicesRequest(Mapping):
        pass

    class ListDevicesResponse(Mapping):
        pass

    class ListGroupsRequest(Mapping):
        pass

    class ListGroupsResponse(Mapping):
        pass

    class ListIdentityProvidersRequest(Mapping):
        pass

    class ListIdentityProvidersResponse(Mapping):
        pass

    class ListResourceServersRequest(Mapping):
        pass

    class ListResourceServersResponse(Mapping):
        pass

    class ListUserImportJobsRequest(Mapping):
        pass

    class ListUserImportJobsResponse(Mapping):
        pass

    class ListUserPoolClientsRequest(Mapping):
        pass

    class ListUserPoolClientsResponse(Mapping):
        pass

    class ListUserPoolsRequest(Mapping):
        pass

    class ListUserPoolsResponse(Mapping):
        pass

    class ListUsersRequest(Mapping):
        pass

    class ListUsersResponse(Mapping):
        pass

    class ListUsersInGroupRequest(Mapping):
        pass

    class ListUsersInGroupResponse(Mapping):
        pass

    class ResendConfirmationCodeRequest(Mapping):
        pass

    class ResendConfirmationCodeResponse(Mapping):
        pass

    class RespondToAuthChallengeRequest(Mapping):
        pass

    class RespondToAuthChallengeResponse(Mapping):
        pass

    class SetRiskConfigurationRequest(Mapping):
        pass

    class SetRiskConfigurationResponse(Mapping):
        pass

    class CompromisedCredentialsRiskConfigurationType(Mapping):
        pass

    class AccountTakeoverRiskConfigurationType(Mapping):
        pass

    class RiskExceptionConfigurationType(Mapping):
        pass

    class SetUICustomizationRequest(Mapping):
        pass

    class SetUICustomizationResponse(Mapping):
        pass

    class ImageFileType(object):
        pass

    class SetUserMFAPreferenceRequest(Mapping):
        pass

    class SetUserMFAPreferenceResponse(Mapping):
        pass

    class SetUserPoolMfaConfigRequest(Mapping):
        pass

    class SetUserPoolMfaConfigResponse(Mapping):
        pass

    class SmsMfaConfigType(Mapping):
        pass

    class SoftwareTokenMfaConfigType(Mapping):
        pass

    class SetUserSettingsRequest(Mapping):
        pass

    class SetUserSettingsResponse(Mapping):
        pass

    class SignUpRequest(Mapping):
        pass

    class SignUpResponse(Mapping):
        pass

    class StartUserImportJobRequest(Mapping):
        pass

    class StartUserImportJobResponse(Mapping):
        pass

    class StopUserImportJobRequest(Mapping):
        pass

    class StopUserImportJobResponse(Mapping):
        pass

    class UpdateAuthEventFeedbackRequest(Mapping):
        pass

    class UpdateAuthEventFeedbackResponse(Mapping):
        pass

    class UpdateDeviceStatusRequest(Mapping):
        pass

    class UpdateDeviceStatusResponse(Mapping):
        pass

    class UpdateGroupRequest(Mapping):
        pass

    class UpdateGroupResponse(Mapping):
        pass

    class UpdateIdentityProviderRequest(Mapping):
        pass

    class UpdateIdentityProviderResponse(Mapping):
        pass

    class UpdateResourceServerRequest(Mapping):
        pass

    class UpdateResourceServerResponse(Mapping):
        pass

    class UpdateUserAttributesRequest(Mapping):
        pass

    class UpdateUserAttributesResponse(Mapping):
        pass

    class UpdateUserPoolRequest(Mapping):
        pass

    class UpdateUserPoolResponse(Mapping):
        pass

    class UpdateUserPoolClientRequest(Mapping):
        pass

    class UpdateUserPoolClientResponse(Mapping):
        pass

    class UpdateUserPoolDomainRequest(Mapping):
        pass

    class UpdateUserPoolDomainResponse(Mapping):
        pass

    class VerifySoftwareTokenRequest(Mapping):
        pass

    class VerifySoftwareTokenResponse(Mapping):
        pass

    class VerifyUserAttributeRequest(Mapping):
        pass

    class VerifyUserAttributeResponse(Mapping):
        pass

    def add_custom_attributes(self, CustomAttributes: List[SchemaAttributeType], UserPoolId: str) -> AddCustomAttributesResponse:
        pass

    def admin_add_user_to_group(self, GroupName: str, Username: str, UserPoolId: str):
        pass

    def admin_confirm_sign_up(self, Username: str, UserPoolId: str) -> AdminConfirmSignUpResponse:
        pass

    def admin_create_user(self, Username: str, UserPoolId: str, UserAttributes: List[AttributeType]=None, ValidationData: List[AttributeType]=None, TemporaryPassword: str=None, ForceAliasCreation: ForceAliasCreation=None, MessageAction: str=None, DesiredDeliveryMediums: List[DeliveryMediumType]=None) -> AdminCreateUserResponse:
        pass

    def admin_delete_user(self, Username: str, UserPoolId: str):
        pass

    def admin_delete_user_attributes(self, UserAttributeNames: List[AttributeNameType], Username: str, UserPoolId: str) -> AdminDeleteUserAttributesResponse:
        pass

    def admin_disable_provider_for_user(self, User: ProviderUserIdentifierType, UserPoolId: str) -> AdminDisableProviderForUserResponse:
        pass

    def admin_disable_user(self, Username: str, UserPoolId: str) -> AdminDisableUserResponse:
        pass

    def admin_enable_user(self, Username: str, UserPoolId: str) -> AdminEnableUserResponse:
        pass

    def admin_forget_device(self, DeviceKey: str, Username: str, UserPoolId: str):
        pass

    def admin_get_device(self, Username: str, UserPoolId: str, DeviceKey: str) -> AdminGetDeviceResponse:
        pass

    def admin_get_user(self, Username: str, UserPoolId: str) -> AdminGetUserResponse:
        pass

    def admin_initiate_auth(self, AuthFlow: str, ClientId: str, UserPoolId: str, AuthParameters: AuthParametersType=None, ClientMetadata: ClientMetadataType=None, AnalyticsMetadata: AnalyticsMetadataType=None, ContextData: ContextDataType=None) -> AdminInitiateAuthResponse:
        pass

    def admin_link_provider_for_user(self, SourceUser: ProviderUserIdentifierType, DestinationUser: ProviderUserIdentifierType, UserPoolId: str) -> AdminLinkProviderForUserResponse:
        pass

    def admin_list_devices(self, Username: str, UserPoolId: str, Limit: int=None, PaginationToken: str=None) -> AdminListDevicesResponse:
        pass

    def admin_list_groups_for_user(self, UserPoolId: str, Username: str, Limit: int=None, NextToken: str=None) -> AdminListGroupsForUserResponse:
        pass

    def admin_list_user_auth_events(self, Username: str, UserPoolId: str, MaxResults: int=None, NextToken: str=None) -> AdminListUserAuthEventsResponse:
        pass

    def admin_remove_user_from_group(self, GroupName: str, Username: str, UserPoolId: str):
        pass

    def admin_reset_user_password(self, Username: str, UserPoolId: str) -> AdminResetUserPasswordResponse:
        pass

    def admin_respond_to_auth_challenge(self, ChallengeName: str, ClientId: str, UserPoolId: str, ChallengeResponses: ChallengeResponsesType=None, Session: str=None, AnalyticsMetadata: AnalyticsMetadataType=None, ContextData: ContextDataType=None) -> AdminRespondToAuthChallengeResponse:
        pass

    def admin_set_user_mfa_preference(self, UserPoolId: str, Username: str, SMSMfaSettings: SMSMfaSettingsType=None, SoftwareTokenMfaSettings: SoftwareTokenMfaSettingsType=None) -> AdminSetUserMFAPreferenceResponse:
        pass

    def admin_set_user_settings(self, MFAOptions: List[MFAOptionType], Username: str, UserPoolId: str) -> AdminSetUserSettingsResponse:
        pass

    def admin_update_auth_event_feedback(self, FeedbackValue: str, EventId: str, Username: str, UserPoolId: str) -> AdminUpdateAuthEventFeedbackResponse:
        pass

    def admin_update_device_status(self, DeviceKey: str, Username: str, UserPoolId: str, DeviceRememberedStatus: str=None) -> AdminUpdateDeviceStatusResponse:
        pass

    def admin_update_user_attributes(self, UserAttributes: List[AttributeType], Username: str, UserPoolId: str) -> AdminUpdateUserAttributesResponse:
        pass

    def admin_user_global_sign_out(self, Username: str, UserPoolId: str) -> AdminUserGlobalSignOutResponse:
        pass

    def associate_software_token(self, AccessToken: str=None, Session: str=None) -> AssociateSoftwareTokenResponse:
        pass

    def change_password(self, AccessToken: str, ProposedPassword: str, PreviousPassword: str) -> ChangePasswordResponse:
        pass

    def confirm_device(self, DeviceKey: str, AccessToken: str, DeviceSecretVerifierConfig: DeviceSecretVerifierConfigType=None, DeviceName: str=None) -> ConfirmDeviceResponse:
        pass

    def confirm_forgot_password(self, Password: str, ConfirmationCode: str, Username: str, ClientId: str, SecretHash: str=None, AnalyticsMetadata: AnalyticsMetadataType=None, UserContextData: UserContextDataType=None) -> ConfirmForgotPasswordResponse:
        pass

    def confirm_sign_up(self, ConfirmationCode: str, Username: str, ClientId: str, SecretHash: str=None, ForceAliasCreation: ForceAliasCreation=None, AnalyticsMetadata: AnalyticsMetadataType=None, UserContextData: UserContextDataType=None) -> ConfirmSignUpResponse:
        pass

    def create_group(self, UserPoolId: str, GroupName: str, Description: str=None, RoleArn: str=None, Precedence: int=None) -> CreateGroupResponse:
        pass

    def create_identity_provider(self, ProviderDetails: ProviderDetailsType, ProviderType: str, ProviderName: str, UserPoolId: str, AttributeMapping: AttributeMappingType=None, IdpIdentifiers: List[IdpIdentifierType]=None) -> CreateIdentityProviderResponse:
        pass

    def create_resource_server(self, Name: str, Identifier: str, UserPoolId: str, Scopes: List[ResourceServerScopeType]=None) -> CreateResourceServerResponse:
        pass

    def create_user_import_job(self, CloudWatchLogsRoleArn: str, UserPoolId: str, JobName: str) -> CreateUserImportJobResponse:
        pass

    def create_user_pool(self, PoolName: str, Policies: UserPoolPolicyType=None, LambdaConfig: LambdaConfigType=None, AutoVerifiedAttributes: List[VerifiedAttributeType]=None, AliasAttributes: List[AliasAttributeType]=None, UsernameAttributes: List[UsernameAttributeType]=None, SmsVerificationMessage: str=None, EmailVerificationMessage: str=None, EmailVerificationSubject: str=None, VerificationMessageTemplate: VerificationMessageTemplateType=None, SmsAuthenticationMessage: str=None, MfaConfiguration: str=None, DeviceConfiguration: DeviceConfigurationType=None, EmailConfiguration: EmailConfigurationType=None, SmsConfiguration: SmsConfigurationType=None, UserPoolTags: UserPoolTagsType=None, AdminCreateUserConfig: AdminCreateUserConfigType=None, Schema: List[SchemaAttributeType]=None, UserPoolAddOns: UserPoolAddOnsType=None) -> CreateUserPoolResponse:
        pass

    def create_user_pool_client(self, ClientName: str, UserPoolId: str, GenerateSecret: GenerateSecret=None, RefreshTokenValidity: int=None, ReadAttributes: List[ClientPermissionType]=None, WriteAttributes: List[ClientPermissionType]=None, ExplicitAuthFlows: List[ExplicitAuthFlowsType]=None, SupportedIdentityProviders: List[ProviderNameType]=None, CallbackURLs: List[RedirectUrlType]=None, LogoutURLs: List[RedirectUrlType]=None, DefaultRedirectURI: str=None, AllowedOAuthFlows: List[OAuthFlowType]=None, AllowedOAuthScopes: List[ScopeType]=None, AllowedOAuthFlowsUserPoolClient: BooleanType=None, AnalyticsConfiguration: AnalyticsConfigurationType=None) -> CreateUserPoolClientResponse:
        pass

    def create_user_pool_domain(self, UserPoolId: str, Domain: str, CustomDomainConfig: CustomDomainConfigType=None) -> CreateUserPoolDomainResponse:
        pass

    def delete_group(self, UserPoolId: str, GroupName: str):
        pass

    def delete_identity_provider(self, ProviderName: str, UserPoolId: str):
        pass

    def delete_resource_server(self, Identifier: str, UserPoolId: str):
        pass

    def delete_user(self, AccessToken: str):
        pass

    def delete_user_attributes(self, AccessToken: str, UserAttributeNames: List[AttributeNameType]) -> DeleteUserAttributesResponse:
        pass

    def delete_user_pool(self, UserPoolId: str):
        pass

    def delete_user_pool_client(self, ClientId: str, UserPoolId: str):
        pass

    def delete_user_pool_domain(self, UserPoolId: str, Domain: str) -> DeleteUserPoolDomainResponse:
        pass

    def describe_identity_provider(self, ProviderName: str, UserPoolId: str) -> DescribeIdentityProviderResponse:
        pass

    def describe_resource_server(self, Identifier: str, UserPoolId: str) -> DescribeResourceServerResponse:
        pass

    def describe_risk_configuration(self, UserPoolId: str, ClientId: str=None) -> DescribeRiskConfigurationResponse:
        pass

    def describe_user_import_job(self, JobId: str, UserPoolId: str) -> DescribeUserImportJobResponse:
        pass

    def describe_user_pool(self, UserPoolId: str) -> DescribeUserPoolResponse:
        pass

    def describe_user_pool_client(self, ClientId: str, UserPoolId: str) -> DescribeUserPoolClientResponse:
        pass

    def describe_user_pool_domain(self, Domain: str) -> DescribeUserPoolDomainResponse:
        pass

    def forget_device(self, DeviceKey: str, AccessToken: str=None):
        pass

    def forgot_password(self, Username: str, ClientId: str, SecretHash: str=None, UserContextData: UserContextDataType=None, AnalyticsMetadata: AnalyticsMetadataType=None) -> ForgotPasswordResponse:
        pass

    def get_csv_header(self, UserPoolId: str) -> GetCSVHeaderResponse:
        pass

    def get_device(self, DeviceKey: str, AccessToken: str=None) -> GetDeviceResponse:
        pass

    def get_group(self, UserPoolId: str, GroupName: str) -> GetGroupResponse:
        pass

    def get_identity_provider_by_identifier(self, IdpIdentifier: str, UserPoolId: str) -> GetIdentityProviderByIdentifierResponse:
        pass

    def get_signing_certificate(self, UserPoolId: str) -> GetSigningCertificateResponse:
        pass

    def get_ui_customization(self, UserPoolId: str, ClientId: str=None) -> GetUICustomizationResponse:
        pass

    def get_user(self, AccessToken: str) -> GetUserResponse:
        pass

    def get_user_attribute_verification_code(self, AttributeName: str, AccessToken: str) -> GetUserAttributeVerificationCodeResponse:
        pass

    def get_user_pool_mfa_config(self, UserPoolId: str) -> GetUserPoolMfaConfigResponse:
        pass

    def global_sign_out(self, AccessToken: str) -> GlobalSignOutResponse:
        pass

    def initiate_auth(self, ClientId: str, AuthFlow: str, AuthParameters: AuthParametersType=None, ClientMetadata: ClientMetadataType=None, AnalyticsMetadata: AnalyticsMetadataType=None, UserContextData: UserContextDataType=None) -> InitiateAuthResponse:
        pass

    def list_devices(self, AccessToken: str, Limit: int=None, PaginationToken: str=None) -> ListDevicesResponse:
        pass

    def list_groups(self, UserPoolId: str, Limit: int=None, NextToken: str=None) -> ListGroupsResponse:
        pass

    def list_identity_providers(self, UserPoolId: str, MaxResults: int=None, NextToken: str=None) -> ListIdentityProvidersResponse:
        pass

    def list_resource_servers(self, UserPoolId: str, MaxResults: int=None, NextToken: str=None) -> ListResourceServersResponse:
        pass

    def list_user_import_jobs(self, MaxResults: int, UserPoolId: str, PaginationToken: str=None) -> ListUserImportJobsResponse:
        pass

    def list_user_pool_clients(self, UserPoolId: str, MaxResults: int=None, NextToken: str=None) -> ListUserPoolClientsResponse:
        pass

    def list_user_pools(self, MaxResults: int, NextToken: str=None) -> ListUserPoolsResponse:
        pass

    def list_users(self, UserPoolId: str, AttributesToGet: List[AttributeNameType]=None, Limit: int=None, PaginationToken: str=None, Filter: str=None) -> ListUsersResponse:
        pass

    def list_users_in_group(self, GroupName: str, UserPoolId: str, Limit: int=None, NextToken: str=None) -> ListUsersInGroupResponse:
        pass

    def resend_confirmation_code(self, Username: str, ClientId: str, SecretHash: str=None, UserContextData: UserContextDataType=None, AnalyticsMetadata: AnalyticsMetadataType=None) -> ResendConfirmationCodeResponse:
        pass

    def respond_to_auth_challenge(self, ChallengeName: str, ClientId: str, Session: str=None, ChallengeResponses: ChallengeResponsesType=None, AnalyticsMetadata: AnalyticsMetadataType=None, UserContextData: UserContextDataType=None) -> RespondToAuthChallengeResponse:
        pass

    def set_risk_configuration(self, UserPoolId: str, ClientId: str=None, CompromisedCredentialsRiskConfiguration: CompromisedCredentialsRiskConfigurationType=None, AccountTakeoverRiskConfiguration: AccountTakeoverRiskConfigurationType=None, RiskExceptionConfiguration: RiskExceptionConfigurationType=None) -> SetRiskConfigurationResponse:
        pass

    def set_ui_customization(self, UserPoolId: str, ClientId: str=None, CSS: str=None, ImageFile: ImageFileType=None) -> SetUICustomizationResponse:
        pass

    def set_user_mfa_preference(self, AccessToken: str, SMSMfaSettings: SMSMfaSettingsType=None, SoftwareTokenMfaSettings: SoftwareTokenMfaSettingsType=None) -> SetUserMFAPreferenceResponse:
        pass

    def set_user_pool_mfa_config(self, UserPoolId: str, SmsMfaConfiguration: SmsMfaConfigType=None, SoftwareTokenMfaConfiguration: SoftwareTokenMfaConfigType=None, MfaConfiguration: str=None) -> SetUserPoolMfaConfigResponse:
        pass

    def set_user_settings(self, MFAOptions: List[MFAOptionType], AccessToken: str) -> SetUserSettingsResponse:
        pass

    def sign_up(self, Password: str, Username: str, ClientId: str, SecretHash: str=None, UserAttributes: List[AttributeType]=None, ValidationData: List[AttributeType]=None, AnalyticsMetadata: AnalyticsMetadataType=None, UserContextData: UserContextDataType=None) -> SignUpResponse:
        pass

    def start_user_import_job(self, JobId: str, UserPoolId: str) -> StartUserImportJobResponse:
        pass

    def stop_user_import_job(self, JobId: str, UserPoolId: str) -> StopUserImportJobResponse:
        pass

    def update_auth_event_feedback(self, FeedbackValue: str, FeedbackToken: str, EventId: str, Username: str, UserPoolId: str) -> UpdateAuthEventFeedbackResponse:
        pass

    def update_device_status(self, DeviceKey: str, AccessToken: str, DeviceRememberedStatus: str=None) -> UpdateDeviceStatusResponse:
        pass

    def update_group(self, UserPoolId: str, GroupName: str, Description: str=None, RoleArn: str=None, Precedence: int=None) -> UpdateGroupResponse:
        pass

    def update_identity_provider(self, ProviderName: str, UserPoolId: str, ProviderDetails: ProviderDetailsType=None, AttributeMapping: AttributeMappingType=None, IdpIdentifiers: List[IdpIdentifierType]=None) -> UpdateIdentityProviderResponse:
        pass

    def update_resource_server(self, Name: str, Identifier: str, UserPoolId: str, Scopes: List[ResourceServerScopeType]=None) -> UpdateResourceServerResponse:
        pass

    def update_user_attributes(self, AccessToken: str, UserAttributes: List[AttributeType]) -> UpdateUserAttributesResponse:
        pass

    def update_user_pool(self, UserPoolId: str, Policies: UserPoolPolicyType=None, LambdaConfig: LambdaConfigType=None, AutoVerifiedAttributes: List[VerifiedAttributeType]=None, SmsVerificationMessage: str=None, EmailVerificationMessage: str=None, EmailVerificationSubject: str=None, VerificationMessageTemplate: VerificationMessageTemplateType=None, SmsAuthenticationMessage: str=None, MfaConfiguration: str=None, DeviceConfiguration: DeviceConfigurationType=None, EmailConfiguration: EmailConfigurationType=None, SmsConfiguration: SmsConfigurationType=None, UserPoolTags: UserPoolTagsType=None, AdminCreateUserConfig: AdminCreateUserConfigType=None, UserPoolAddOns: UserPoolAddOnsType=None) -> UpdateUserPoolResponse:
        pass

    def update_user_pool_client(self, ClientId: str, UserPoolId: str, ClientName: str=None, RefreshTokenValidity: int=None, ReadAttributes: List[ClientPermissionType]=None, WriteAttributes: List[ClientPermissionType]=None, ExplicitAuthFlows: List[ExplicitAuthFlowsType]=None, SupportedIdentityProviders: List[ProviderNameType]=None, CallbackURLs: List[RedirectUrlType]=None, LogoutURLs: List[RedirectUrlType]=None, DefaultRedirectURI: str=None, AllowedOAuthFlows: List[OAuthFlowType]=None, AllowedOAuthScopes: List[ScopeType]=None, AllowedOAuthFlowsUserPoolClient: BooleanType=None, AnalyticsConfiguration: AnalyticsConfigurationType=None) -> UpdateUserPoolClientResponse:
        pass

    def update_user_pool_domain(self, CustomDomainConfig: CustomDomainConfigType, UserPoolId: str, Domain: str) -> UpdateUserPoolDomainResponse:
        pass

    def verify_software_token(self, UserCode: str, AccessToken: str=None, Session: str=None, FriendlyDeviceName: str=None) -> VerifySoftwareTokenResponse:
        pass

    def verify_user_attribute(self, Code: str, AttributeName: str, AccessToken: str) -> VerifyUserAttributeResponse:
        pass


class CognitoSync(BaseClient):
    class BulkPublishRequest(Mapping):
        pass

    class BulkPublishResponse(Mapping):
        pass

    class DeleteDatasetRequest(Mapping):
        pass

    class DeleteDatasetResponse(Mapping):
        pass

    class DescribeDatasetRequest(Mapping):
        pass

    class DescribeDatasetResponse(Mapping):
        pass

    class DescribeIdentityPoolUsageRequest(Mapping):
        pass

    class DescribeIdentityPoolUsageResponse(Mapping):
        pass

    class DescribeIdentityUsageRequest(Mapping):
        pass

    class DescribeIdentityUsageResponse(Mapping):
        pass

    class GetBulkPublishDetailsRequest(Mapping):
        pass

    class GetBulkPublishDetailsResponse(Mapping):
        pass

    class GetCognitoEventsRequest(Mapping):
        pass

    class GetCognitoEventsResponse(Mapping):
        pass

    class GetIdentityPoolConfigurationRequest(Mapping):
        pass

    class GetIdentityPoolConfigurationResponse(Mapping):
        pass

    class ListDatasetsRequest(Mapping):
        pass

    class ListDatasetsResponse(Mapping):
        pass

    class ListIdentityPoolUsageRequest(Mapping):
        pass

    class ListIdentityPoolUsageResponse(Mapping):
        pass

    class ListRecordsRequest(Mapping):
        pass

    class ListRecordsResponse(Mapping):
        pass

    class Long(object):
        pass

    class RegisterDeviceRequest(Mapping):
        pass

    class RegisterDeviceResponse(Mapping):
        pass

    class SetCognitoEventsRequest(Mapping):
        pass

    class Events(object):
        pass

    class SetIdentityPoolConfigurationRequest(Mapping):
        pass

    class SetIdentityPoolConfigurationResponse(Mapping):
        pass

    class PushSync(Mapping):
        pass

    class CognitoStreams(Mapping):
        pass

    class SubscribeToDatasetRequest(Mapping):
        pass

    class SubscribeToDatasetResponse(Mapping):
        pass

    class UnsubscribeFromDatasetRequest(Mapping):
        pass

    class UnsubscribeFromDatasetResponse(Mapping):
        pass

    class UpdateRecordsRequest(Mapping):
        pass

    class UpdateRecordsResponse(Mapping):
        pass

    class RecordPatch(Mapping):
        pass

    def bulk_publish(self, IdentityPoolId: str) -> BulkPublishResponse:
        pass

    def delete_dataset(self, DatasetName: str, IdentityId: str, IdentityPoolId: str) -> DeleteDatasetResponse:
        pass

    def describe_dataset(self, DatasetName: str, IdentityId: str, IdentityPoolId: str) -> DescribeDatasetResponse:
        pass

    def describe_identity_pool_usage(self, IdentityPoolId: str) -> DescribeIdentityPoolUsageResponse:
        pass

    def describe_identity_usage(self, IdentityId: str, IdentityPoolId: str) -> DescribeIdentityUsageResponse:
        pass

    def get_bulk_publish_details(self, IdentityPoolId: str) -> GetBulkPublishDetailsResponse:
        pass

    def get_cognito_events(self, IdentityPoolId: str) -> GetCognitoEventsResponse:
        pass

    def get_identity_pool_configuration(self, IdentityPoolId: str) -> GetIdentityPoolConfigurationResponse:
        pass

    def list_datasets(self, IdentityId: str, IdentityPoolId: str, NextToken: str=None, MaxResults: int=None) -> ListDatasetsResponse:
        pass

    def list_identity_pool_usage(self, NextToken: str=None, MaxResults: int=None) -> ListIdentityPoolUsageResponse:
        pass

    def list_records(self, DatasetName: str, IdentityId: str, IdentityPoolId: str, LastSyncCount: Long=None, NextToken: str=None, MaxResults: int=None, SyncSessionToken: str=None) -> ListRecordsResponse:
        pass

    def register_device(self, Token: str, Platform: str, IdentityId: str, IdentityPoolId: str) -> RegisterDeviceResponse:
        pass

    def set_cognito_events(self, Events: Events, IdentityPoolId: str):
        pass

    def set_identity_pool_configuration(self, IdentityPoolId: str, PushSync: PushSync=None, CognitoStreams: CognitoStreams=None) -> SetIdentityPoolConfigurationResponse:
        pass

    def subscribe_to_dataset(self, DeviceId: str, DatasetName: str, IdentityId: str, IdentityPoolId: str) -> SubscribeToDatasetResponse:
        pass

    def unsubscribe_from_dataset(self, DeviceId: str, DatasetName: str, IdentityId: str, IdentityPoolId: str) -> UnsubscribeFromDatasetResponse:
        pass

    def update_records(self, SyncSessionToken: str, DatasetName: str, IdentityId: str, IdentityPoolId: str, DeviceId: str=None, RecordPatches: List[RecordPatch]=None, ClientContext: str=None) -> UpdateRecordsResponse:
        pass


class Comprehend(BaseClient):
    class BatchDetectDominantLanguageRequest(Mapping):
        pass

    class BatchDetectDominantLanguageResponse(Mapping):
        pass

    class String(object):
        pass

    class BatchDetectEntitiesRequest(Mapping):
        pass

    class BatchDetectEntitiesResponse(Mapping):
        pass

    class BatchDetectKeyPhrasesRequest(Mapping):
        pass

    class BatchDetectKeyPhrasesResponse(Mapping):
        pass

    class BatchDetectSentimentRequest(Mapping):
        pass

    class BatchDetectSentimentResponse(Mapping):
        pass

    class BatchDetectSyntaxRequest(Mapping):
        pass

    class BatchDetectSyntaxResponse(Mapping):
        pass

    class CreateDocumentClassifierRequest(Mapping):
        pass

    class CreateDocumentClassifierResponse(Mapping):
        pass

    class DocumentClassifierInputDataConfig(Mapping):
        pass

    class CreateEntityRecognizerRequest(Mapping):
        pass

    class CreateEntityRecognizerResponse(Mapping):
        pass

    class EntityRecognizerInputDataConfig(Mapping):
        pass

    class DeleteDocumentClassifierRequest(Mapping):
        pass

    class DeleteDocumentClassifierResponse(Mapping):
        pass

    class DeleteEntityRecognizerRequest(Mapping):
        pass

    class DeleteEntityRecognizerResponse(Mapping):
        pass

    class DescribeDocumentClassificationJobRequest(Mapping):
        pass

    class DescribeDocumentClassificationJobResponse(Mapping):
        pass

    class DescribeDocumentClassifierRequest(Mapping):
        pass

    class DescribeDocumentClassifierResponse(Mapping):
        pass

    class DescribeDominantLanguageDetectionJobRequest(Mapping):
        pass

    class DescribeDominantLanguageDetectionJobResponse(Mapping):
        pass

    class DescribeEntitiesDetectionJobRequest(Mapping):
        pass

    class DescribeEntitiesDetectionJobResponse(Mapping):
        pass

    class DescribeEntityRecognizerRequest(Mapping):
        pass

    class DescribeEntityRecognizerResponse(Mapping):
        pass

    class DescribeKeyPhrasesDetectionJobRequest(Mapping):
        pass

    class DescribeKeyPhrasesDetectionJobResponse(Mapping):
        pass

    class DescribeSentimentDetectionJobRequest(Mapping):
        pass

    class DescribeSentimentDetectionJobResponse(Mapping):
        pass

    class DescribeTopicsDetectionJobRequest(Mapping):
        pass

    class DescribeTopicsDetectionJobResponse(Mapping):
        pass

    class DetectDominantLanguageRequest(Mapping):
        pass

    class DetectDominantLanguageResponse(Mapping):
        pass

    class DetectEntitiesRequest(Mapping):
        pass

    class DetectEntitiesResponse(Mapping):
        pass

    class DetectKeyPhrasesRequest(Mapping):
        pass

    class DetectKeyPhrasesResponse(Mapping):
        pass

    class DetectSentimentRequest(Mapping):
        pass

    class DetectSentimentResponse(Mapping):
        pass

    class DetectSyntaxRequest(Mapping):
        pass

    class DetectSyntaxResponse(Mapping):
        pass

    class ListDocumentClassificationJobsRequest(Mapping):
        pass

    class ListDocumentClassificationJobsResponse(Mapping):
        pass

    class DocumentClassificationJobFilter(Mapping):
        pass

    class ListDocumentClassifiersRequest(Mapping):
        pass

    class ListDocumentClassifiersResponse(Mapping):
        pass

    class DocumentClassifierFilter(Mapping):
        pass

    class ListDominantLanguageDetectionJobsRequest(Mapping):
        pass

    class ListDominantLanguageDetectionJobsResponse(Mapping):
        pass

    class DominantLanguageDetectionJobFilter(Mapping):
        pass

    class ListEntitiesDetectionJobsRequest(Mapping):
        pass

    class ListEntitiesDetectionJobsResponse(Mapping):
        pass

    class EntitiesDetectionJobFilter(Mapping):
        pass

    class ListEntityRecognizersRequest(Mapping):
        pass

    class ListEntityRecognizersResponse(Mapping):
        pass

    class EntityRecognizerFilter(Mapping):
        pass

    class ListKeyPhrasesDetectionJobsRequest(Mapping):
        pass

    class ListKeyPhrasesDetectionJobsResponse(Mapping):
        pass

    class KeyPhrasesDetectionJobFilter(Mapping):
        pass

    class ListSentimentDetectionJobsRequest(Mapping):
        pass

    class ListSentimentDetectionJobsResponse(Mapping):
        pass

    class SentimentDetectionJobFilter(Mapping):
        pass

    class ListTopicsDetectionJobsRequest(Mapping):
        pass

    class ListTopicsDetectionJobsResponse(Mapping):
        pass

    class TopicsDetectionJobFilter(Mapping):
        pass

    class StartDocumentClassificationJobRequest(Mapping):
        pass

    class StartDocumentClassificationJobResponse(Mapping):
        pass

    class InputDataConfig(Mapping):
        pass

    class OutputDataConfig(Mapping):
        pass

    class StartDominantLanguageDetectionJobRequest(Mapping):
        pass

    class StartDominantLanguageDetectionJobResponse(Mapping):
        pass

    class StartEntitiesDetectionJobRequest(Mapping):
        pass

    class StartEntitiesDetectionJobResponse(Mapping):
        pass

    class StartKeyPhrasesDetectionJobRequest(Mapping):
        pass

    class StartKeyPhrasesDetectionJobResponse(Mapping):
        pass

    class StartSentimentDetectionJobRequest(Mapping):
        pass

    class StartSentimentDetectionJobResponse(Mapping):
        pass

    class StartTopicsDetectionJobRequest(Mapping):
        pass

    class StartTopicsDetectionJobResponse(Mapping):
        pass

    class StopDominantLanguageDetectionJobRequest(Mapping):
        pass

    class StopDominantLanguageDetectionJobResponse(Mapping):
        pass

    class StopEntitiesDetectionJobRequest(Mapping):
        pass

    class StopEntitiesDetectionJobResponse(Mapping):
        pass

    class StopKeyPhrasesDetectionJobRequest(Mapping):
        pass

    class StopKeyPhrasesDetectionJobResponse(Mapping):
        pass

    class StopSentimentDetectionJobRequest(Mapping):
        pass

    class StopSentimentDetectionJobResponse(Mapping):
        pass

    class StopTrainingDocumentClassifierRequest(Mapping):
        pass

    class StopTrainingDocumentClassifierResponse(Mapping):
        pass

    class StopTrainingEntityRecognizerRequest(Mapping):
        pass

    class StopTrainingEntityRecognizerResponse(Mapping):
        pass

    def batch_detect_dominant_language(self, TextList: List[String]) -> BatchDetectDominantLanguageResponse:
        pass

    def batch_detect_entities(self, LanguageCode: str, TextList: List[String]) -> BatchDetectEntitiesResponse:
        pass

    def batch_detect_key_phrases(self, LanguageCode: str, TextList: List[String]) -> BatchDetectKeyPhrasesResponse:
        pass

    def batch_detect_sentiment(self, LanguageCode: str, TextList: List[String]) -> BatchDetectSentimentResponse:
        pass

    def batch_detect_syntax(self, LanguageCode: str, TextList: List[String]) -> BatchDetectSyntaxResponse:
        pass

    def create_document_classifier(self, LanguageCode: str, InputDataConfig: DocumentClassifierInputDataConfig, DataAccessRoleArn: str, DocumentClassifierName: str, ClientRequestToken: str=None) -> CreateDocumentClassifierResponse:
        pass

    def create_entity_recognizer(self, LanguageCode: str, InputDataConfig: EntityRecognizerInputDataConfig, DataAccessRoleArn: str, RecognizerName: str, ClientRequestToken: str=None) -> CreateEntityRecognizerResponse:
        pass

    def delete_document_classifier(self, DocumentClassifierArn: str) -> DeleteDocumentClassifierResponse:
        pass

    def delete_entity_recognizer(self, EntityRecognizerArn: str) -> DeleteEntityRecognizerResponse:
        pass

    def describe_document_classification_job(self, JobId: str) -> DescribeDocumentClassificationJobResponse:
        pass

    def describe_document_classifier(self, DocumentClassifierArn: str) -> DescribeDocumentClassifierResponse:
        pass

    def describe_dominant_language_detection_job(self, JobId: str) -> DescribeDominantLanguageDetectionJobResponse:
        pass

    def describe_entities_detection_job(self, JobId: str) -> DescribeEntitiesDetectionJobResponse:
        pass

    def describe_entity_recognizer(self, EntityRecognizerArn: str) -> DescribeEntityRecognizerResponse:
        pass

    def describe_key_phrases_detection_job(self, JobId: str) -> DescribeKeyPhrasesDetectionJobResponse:
        pass

    def describe_sentiment_detection_job(self, JobId: str) -> DescribeSentimentDetectionJobResponse:
        pass

    def describe_topics_detection_job(self, JobId: str) -> DescribeTopicsDetectionJobResponse:
        pass

    def detect_dominant_language(self, Text: str) -> DetectDominantLanguageResponse:
        pass

    def detect_entities(self, LanguageCode: str, Text: str) -> DetectEntitiesResponse:
        pass

    def detect_key_phrases(self, LanguageCode: str, Text: str) -> DetectKeyPhrasesResponse:
        pass

    def detect_sentiment(self, LanguageCode: str, Text: str) -> DetectSentimentResponse:
        pass

    def detect_syntax(self, LanguageCode: str, Text: str) -> DetectSyntaxResponse:
        pass

    def list_document_classification_jobs(self, Filter: DocumentClassificationJobFilter=None, NextToken: str=None, MaxResults: int=None) -> ListDocumentClassificationJobsResponse:
        pass

    def list_document_classifiers(self, Filter: DocumentClassifierFilter=None, NextToken: str=None, MaxResults: int=None) -> ListDocumentClassifiersResponse:
        pass

    def list_dominant_language_detection_jobs(self, Filter: DominantLanguageDetectionJobFilter=None, NextToken: str=None, MaxResults: int=None) -> ListDominantLanguageDetectionJobsResponse:
        pass

    def list_entities_detection_jobs(self, Filter: EntitiesDetectionJobFilter=None, NextToken: str=None, MaxResults: int=None) -> ListEntitiesDetectionJobsResponse:
        pass

    def list_entity_recognizers(self, Filter: EntityRecognizerFilter=None, NextToken: str=None, MaxResults: int=None) -> ListEntityRecognizersResponse:
        pass

    def list_key_phrases_detection_jobs(self, Filter: KeyPhrasesDetectionJobFilter=None, NextToken: str=None, MaxResults: int=None) -> ListKeyPhrasesDetectionJobsResponse:
        pass

    def list_sentiment_detection_jobs(self, Filter: SentimentDetectionJobFilter=None, NextToken: str=None, MaxResults: int=None) -> ListSentimentDetectionJobsResponse:
        pass

    def list_topics_detection_jobs(self, Filter: TopicsDetectionJobFilter=None, NextToken: str=None, MaxResults: int=None) -> ListTopicsDetectionJobsResponse:
        pass

    def start_document_classification_job(self, DataAccessRoleArn: str, OutputDataConfig: OutputDataConfig, InputDataConfig: InputDataConfig, DocumentClassifierArn: str, JobName: str=None, ClientRequestToken: str=None) -> StartDocumentClassificationJobResponse:
        pass

    def start_dominant_language_detection_job(self, DataAccessRoleArn: str, OutputDataConfig: OutputDataConfig, InputDataConfig: InputDataConfig, JobName: str=None, ClientRequestToken: str=None) -> StartDominantLanguageDetectionJobResponse:
        pass

    def start_entities_detection_job(self, LanguageCode: str, DataAccessRoleArn: str, OutputDataConfig: OutputDataConfig, InputDataConfig: InputDataConfig, JobName: str=None, EntityRecognizerArn: str=None, ClientRequestToken: str=None) -> StartEntitiesDetectionJobResponse:
        pass

    def start_key_phrases_detection_job(self, LanguageCode: str, DataAccessRoleArn: str, OutputDataConfig: OutputDataConfig, InputDataConfig: InputDataConfig, JobName: str=None, ClientRequestToken: str=None) -> StartKeyPhrasesDetectionJobResponse:
        pass

    def start_sentiment_detection_job(self, LanguageCode: str, DataAccessRoleArn: str, OutputDataConfig: OutputDataConfig, InputDataConfig: InputDataConfig, JobName: str=None, ClientRequestToken: str=None) -> StartSentimentDetectionJobResponse:
        pass

    def start_topics_detection_job(self, DataAccessRoleArn: str, OutputDataConfig: OutputDataConfig, InputDataConfig: InputDataConfig, JobName: str=None, NumberOfTopics: int=None, ClientRequestToken: str=None) -> StartTopicsDetectionJobResponse:
        pass

    def stop_dominant_language_detection_job(self, JobId: str) -> StopDominantLanguageDetectionJobResponse:
        pass

    def stop_entities_detection_job(self, JobId: str) -> StopEntitiesDetectionJobResponse:
        pass

    def stop_key_phrases_detection_job(self, JobId: str) -> StopKeyPhrasesDetectionJobResponse:
        pass

    def stop_sentiment_detection_job(self, JobId: str) -> StopSentimentDetectionJobResponse:
        pass

    def stop_training_document_classifier(self, DocumentClassifierArn: str) -> StopTrainingDocumentClassifierResponse:
        pass

    def stop_training_entity_recognizer(self, EntityRecognizerArn: str) -> StopTrainingEntityRecognizerResponse:
        pass


class ComprehendMedical(BaseClient):
    class DetectEntitiesRequest(Mapping):
        pass

    class DetectEntitiesResponse(Mapping):
        pass

    class DetectPHIRequest(Mapping):
        pass

    class DetectPHIResponse(Mapping):
        pass

    def detect_entities(self, Text: str) -> DetectEntitiesResponse:
        pass

    def detect_phi(self, Text: str) -> DetectPHIResponse:
        pass


class ConfigService(BaseClient):
    class BatchGetAggregateResourceConfigRequest(Mapping):
        pass

    class BatchGetAggregateResourceConfigResponse(Mapping):
        pass

    class AggregateResourceIdentifier(Mapping):
        pass

    class BatchGetResourceConfigRequest(Mapping):
        pass

    class BatchGetResourceConfigResponse(Mapping):
        pass

    class ResourceKey(Mapping):
        pass

    class DeleteAggregationAuthorizationRequest(Mapping):
        pass

    class DeleteConfigRuleRequest(Mapping):
        pass

    class DeleteConfigurationAggregatorRequest(Mapping):
        pass

    class DeleteConfigurationRecorderRequest(Mapping):
        pass

    class DeleteDeliveryChannelRequest(Mapping):
        pass

    class DeleteEvaluationResultsRequest(Mapping):
        pass

    class DeleteEvaluationResultsResponse(Mapping):
        pass

    class DeletePendingAggregationRequestRequest(Mapping):
        pass

    class DeleteRetentionConfigurationRequest(Mapping):
        pass

    class DeliverConfigSnapshotRequest(Mapping):
        pass

    class DeliverConfigSnapshotResponse(Mapping):
        pass

    class DescribeAggregateComplianceByConfigRulesRequest(Mapping):
        pass

    class DescribeAggregateComplianceByConfigRulesResponse(Mapping):
        pass

    class ConfigRuleComplianceFilters(Mapping):
        pass

    class DescribeAggregationAuthorizationsRequest(Mapping):
        pass

    class DescribeAggregationAuthorizationsResponse(Mapping):
        pass

    class DescribeComplianceByConfigRuleRequest(Mapping):
        pass

    class DescribeComplianceByConfigRuleResponse(Mapping):
        pass

    class StringWithCharLimit64(object):
        pass

    class ComplianceType(object):
        pass

    class DescribeComplianceByResourceRequest(Mapping):
        pass

    class DescribeComplianceByResourceResponse(Mapping):
        pass

    class DescribeConfigRuleEvaluationStatusRequest(Mapping):
        pass

    class DescribeConfigRuleEvaluationStatusResponse(Mapping):
        pass

    class DescribeConfigRulesRequest(Mapping):
        pass

    class DescribeConfigRulesResponse(Mapping):
        pass

    class DescribeConfigurationAggregatorSourcesStatusRequest(Mapping):
        pass

    class DescribeConfigurationAggregatorSourcesStatusResponse(Mapping):
        pass

    class AggregatedSourceStatusType(object):
        pass

    class DescribeConfigurationAggregatorsRequest(Mapping):
        pass

    class DescribeConfigurationAggregatorsResponse(Mapping):
        pass

    class ConfigurationAggregatorName(object):
        pass

    class DescribeConfigurationRecorderStatusRequest(Mapping):
        pass

    class DescribeConfigurationRecorderStatusResponse(Mapping):
        pass

    class RecorderName(object):
        pass

    class DescribeConfigurationRecordersRequest(Mapping):
        pass

    class DescribeConfigurationRecordersResponse(Mapping):
        pass

    class DescribeDeliveryChannelStatusRequest(Mapping):
        pass

    class DescribeDeliveryChannelStatusResponse(Mapping):
        pass

    class ChannelName(object):
        pass

    class DescribeDeliveryChannelsRequest(Mapping):
        pass

    class DescribeDeliveryChannelsResponse(Mapping):
        pass

    class DescribePendingAggregationRequestsRequest(Mapping):
        pass

    class DescribePendingAggregationRequestsResponse(Mapping):
        pass

    class DescribeRetentionConfigurationsRequest(Mapping):
        pass

    class DescribeRetentionConfigurationsResponse(Mapping):
        pass

    class RetentionConfigurationName(object):
        pass

    class GetAggregateComplianceDetailsByConfigRuleRequest(Mapping):
        pass

    class GetAggregateComplianceDetailsByConfigRuleResponse(Mapping):
        pass

    class GetAggregateConfigRuleComplianceSummaryRequest(Mapping):
        pass

    class GetAggregateConfigRuleComplianceSummaryResponse(Mapping):
        pass

    class ConfigRuleComplianceSummaryFilters(Mapping):
        pass

    class GetAggregateDiscoveredResourceCountsRequest(Mapping):
        pass

    class GetAggregateDiscoveredResourceCountsResponse(Mapping):
        pass

    class ResourceCountFilters(Mapping):
        pass

    class GetAggregateResourceConfigRequest(Mapping):
        pass

    class GetAggregateResourceConfigResponse(Mapping):
        pass

    class GetComplianceDetailsByConfigRuleRequest(Mapping):
        pass

    class GetComplianceDetailsByConfigRuleResponse(Mapping):
        pass

    class GetComplianceDetailsByResourceRequest(Mapping):
        pass

    class GetComplianceDetailsByResourceResponse(Mapping):
        pass

    class GetComplianceSummaryByConfigRuleResponse(Mapping):
        pass

    class GetComplianceSummaryByResourceTypeRequest(Mapping):
        pass

    class GetComplianceSummaryByResourceTypeResponse(Mapping):
        pass

    class StringWithCharLimit256(object):
        pass

    class GetDiscoveredResourceCountsRequest(Mapping):
        pass

    class GetDiscoveredResourceCountsResponse(Mapping):
        pass

    class GetResourceConfigHistoryRequest(Mapping):
        pass

    class GetResourceConfigHistoryResponse(Mapping):
        pass

    class LaterTime(object):
        pass

    class EarlierTime(object):
        pass

    class ListAggregateDiscoveredResourcesRequest(Mapping):
        pass

    class ListAggregateDiscoveredResourcesResponse(Mapping):
        pass

    class ResourceFilters(Mapping):
        pass

    class ListDiscoveredResourcesRequest(Mapping):
        pass

    class ListDiscoveredResourcesResponse(Mapping):
        pass

    class ResourceId(object):
        pass

    class Boolean(object):
        pass

    class PutAggregationAuthorizationRequest(Mapping):
        pass

    class PutAggregationAuthorizationResponse(Mapping):
        pass

    class PutConfigRuleRequest(Mapping):
        pass

    class ConfigRule(Mapping):
        pass

    class PutConfigurationAggregatorRequest(Mapping):
        pass

    class PutConfigurationAggregatorResponse(Mapping):
        pass

    class AccountAggregationSource(Mapping):
        pass

    class OrganizationAggregationSource(Mapping):
        pass

    class PutConfigurationRecorderRequest(Mapping):
        pass

    class ConfigurationRecorder(Mapping):
        pass

    class PutDeliveryChannelRequest(Mapping):
        pass

    class DeliveryChannel(Mapping):
        pass

    class PutEvaluationsRequest(Mapping):
        pass

    class PutEvaluationsResponse(Mapping):
        pass

    class Evaluation(Mapping):
        pass

    class PutRetentionConfigurationRequest(Mapping):
        pass

    class PutRetentionConfigurationResponse(Mapping):
        pass

    class StartConfigRulesEvaluationRequest(Mapping):
        pass

    class StartConfigRulesEvaluationResponse(Mapping):
        pass

    class StartConfigurationRecorderRequest(Mapping):
        pass

    class StopConfigurationRecorderRequest(Mapping):
        pass

    def batch_get_aggregate_resource_config(self, ResourceIdentifiers: List[AggregateResourceIdentifier], ConfigurationAggregatorName: str) -> BatchGetAggregateResourceConfigResponse:
        pass

    def batch_get_resource_config(self, resourceKeys: List[ResourceKey]) -> BatchGetResourceConfigResponse:
        pass

    def delete_aggregation_authorization(self, AuthorizedAwsRegion: str, AuthorizedAccountId: str):
        pass

    def delete_config_rule(self, ConfigRuleName: str):
        pass

    def delete_configuration_aggregator(self, ConfigurationAggregatorName: str):
        pass

    def delete_configuration_recorder(self, ConfigurationRecorderName: str):
        pass

    def delete_delivery_channel(self, DeliveryChannelName: str):
        pass

    def delete_evaluation_results(self, ConfigRuleName: str) -> DeleteEvaluationResultsResponse:
        pass

    def delete_pending_aggregation_request(self, RequesterAwsRegion: str, RequesterAccountId: str):
        pass

    def delete_retention_configuration(self, RetentionConfigurationName: str):
        pass

    def deliver_config_snapshot(self, deliveryChannelName: str) -> DeliverConfigSnapshotResponse:
        pass

    def describe_aggregate_compliance_by_config_rules(self, ConfigurationAggregatorName: str, Filters: ConfigRuleComplianceFilters=None, Limit: int=None, NextToken: str=None) -> DescribeAggregateComplianceByConfigRulesResponse:
        pass

    def describe_aggregation_authorizations(self, Limit: int=None, NextToken: str=None) -> DescribeAggregationAuthorizationsResponse:
        pass

    def describe_compliance_by_config_rule(self, ConfigRuleNames: List[StringWithCharLimit64]=None, ComplianceTypes: List[ComplianceType]=None, NextToken: str=None) -> DescribeComplianceByConfigRuleResponse:
        pass

    def describe_compliance_by_resource(self, ResourceType: str=None, ResourceId: str=None, ComplianceTypes: List[ComplianceType]=None, Limit: int=None, NextToken: str=None) -> DescribeComplianceByResourceResponse:
        pass

    def describe_config_rule_evaluation_status(self, ConfigRuleNames: List[StringWithCharLimit64]=None, NextToken: str=None, Limit: int=None) -> DescribeConfigRuleEvaluationStatusResponse:
        pass

    def describe_config_rules(self, ConfigRuleNames: List[StringWithCharLimit64]=None, NextToken: str=None) -> DescribeConfigRulesResponse:
        pass

    def describe_configuration_aggregator_sources_status(self, ConfigurationAggregatorName: str, UpdateStatus: List[AggregatedSourceStatusType]=None, NextToken: str=None, Limit: int=None) -> DescribeConfigurationAggregatorSourcesStatusResponse:
        pass

    def describe_configuration_aggregators(self, ConfigurationAggregatorNames: List[ConfigurationAggregatorName]=None, NextToken: str=None, Limit: int=None) -> DescribeConfigurationAggregatorsResponse:
        pass

    def describe_configuration_recorder_status(self, ConfigurationRecorderNames: List[RecorderName]=None) -> DescribeConfigurationRecorderStatusResponse:
        pass

    def describe_configuration_recorders(self, ConfigurationRecorderNames: List[RecorderName]=None) -> DescribeConfigurationRecordersResponse:
        pass

    def describe_delivery_channel_status(self, DeliveryChannelNames: List[ChannelName]=None) -> DescribeDeliveryChannelStatusResponse:
        pass

    def describe_delivery_channels(self, DeliveryChannelNames: List[ChannelName]=None) -> DescribeDeliveryChannelsResponse:
        pass

    def describe_pending_aggregation_requests(self, Limit: int=None, NextToken: str=None) -> DescribePendingAggregationRequestsResponse:
        pass

    def describe_retention_configurations(self, RetentionConfigurationNames: List[RetentionConfigurationName]=None, NextToken: str=None) -> DescribeRetentionConfigurationsResponse:
        pass

    def get_aggregate_compliance_details_by_config_rule(self, AwsRegion: str, AccountId: str, ConfigRuleName: str, ConfigurationAggregatorName: str, ComplianceType: str=None, Limit: int=None, NextToken: str=None) -> GetAggregateComplianceDetailsByConfigRuleResponse:
        pass

    def get_aggregate_config_rule_compliance_summary(self, ConfigurationAggregatorName: str, Filters: ConfigRuleComplianceSummaryFilters=None, GroupByKey: str=None, Limit: int=None, NextToken: str=None) -> GetAggregateConfigRuleComplianceSummaryResponse:
        pass

    def get_aggregate_discovered_resource_counts(self, ConfigurationAggregatorName: str, Filters: ResourceCountFilters=None, GroupByKey: str=None, Limit: int=None, NextToken: str=None) -> GetAggregateDiscoveredResourceCountsResponse:
        pass

    def get_aggregate_resource_config(self, ResourceIdentifier: AggregateResourceIdentifier, ConfigurationAggregatorName: str) -> GetAggregateResourceConfigResponse:
        pass

    def get_compliance_details_by_config_rule(self, ConfigRuleName: str, ComplianceTypes: List[ComplianceType]=None, Limit: int=None, NextToken: str=None) -> GetComplianceDetailsByConfigRuleResponse:
        pass

    def get_compliance_details_by_resource(self, ResourceId: str, ResourceType: str, ComplianceTypes: List[ComplianceType]=None, NextToken: str=None) -> GetComplianceDetailsByResourceResponse:
        pass

    def get_compliance_summary_by_config_rule(self) -> GetComplianceSummaryByConfigRuleResponse:
        pass

    def get_compliance_summary_by_resource_type(self, ResourceTypes: List[StringWithCharLimit256]=None) -> GetComplianceSummaryByResourceTypeResponse:
        pass

    def get_discovered_resource_counts(self, resourceTypes: List[StringWithCharLimit256]=None, limit: int=None, nextToken: str=None) -> GetDiscoveredResourceCountsResponse:
        pass

    def get_resource_config_history(self, resourceId: str, resourceType: str, laterTime: LaterTime=None, earlierTime: EarlierTime=None, chronologicalOrder: str=None, limit: int=None, nextToken: str=None) -> GetResourceConfigHistoryResponse:
        pass

    def list_aggregate_discovered_resources(self, ResourceType: str, ConfigurationAggregatorName: str, Filters: ResourceFilters=None, Limit: int=None, NextToken: str=None) -> ListAggregateDiscoveredResourcesResponse:
        pass

    def list_discovered_resources(self, resourceType: str, resourceIds: List[ResourceId]=None, resourceName: str=None, limit: int=None, includeDeletedResources: Boolean=None, nextToken: str=None) -> ListDiscoveredResourcesResponse:
        pass

    def put_aggregation_authorization(self, AuthorizedAwsRegion: str, AuthorizedAccountId: str) -> PutAggregationAuthorizationResponse:
        pass

    def put_config_rule(self, ConfigRule: ConfigRule):
        pass

    def put_configuration_aggregator(self, ConfigurationAggregatorName: str, AccountAggregationSources: List[AccountAggregationSource]=None, OrganizationAggregationSource: OrganizationAggregationSource=None) -> PutConfigurationAggregatorResponse:
        pass

    def put_configuration_recorder(self, ConfigurationRecorder: ConfigurationRecorder):
        pass

    def put_delivery_channel(self, DeliveryChannel: DeliveryChannel):
        pass

    def put_evaluations(self, ResultToken: str, Evaluations: List[Evaluation]=None, TestMode: Boolean=None) -> PutEvaluationsResponse:
        pass

    def put_retention_configuration(self, RetentionPeriodInDays: int) -> PutRetentionConfigurationResponse:
        pass

    def start_config_rules_evaluation(self, ConfigRuleNames: List[StringWithCharLimit64]=None) -> StartConfigRulesEvaluationResponse:
        pass

    def start_configuration_recorder(self, ConfigurationRecorderName: str):
        pass

    def stop_configuration_recorder(self, ConfigurationRecorderName: str):
        pass


class Connect(BaseClient):
    class CreateUserRequest(Mapping):
        pass

    class CreateUserResponse(Mapping):
        pass

    class UserIdentityInfo(Mapping):
        pass

    class UserPhoneConfig(Mapping):
        pass

    class SecurityProfileId(object):
        pass

    class DeleteUserRequest(Mapping):
        pass

    class DescribeUserRequest(Mapping):
        pass

    class DescribeUserResponse(Mapping):
        pass

    class DescribeUserHierarchyGroupRequest(Mapping):
        pass

    class DescribeUserHierarchyGroupResponse(Mapping):
        pass

    class DescribeUserHierarchyStructureRequest(Mapping):
        pass

    class DescribeUserHierarchyStructureResponse(Mapping):
        pass

    class GetContactAttributesRequest(Mapping):
        pass

    class GetContactAttributesResponse(Mapping):
        pass

    class GetCurrentMetricDataRequest(Mapping):
        pass

    class GetCurrentMetricDataResponse(Mapping):
        pass

    class Filters(Mapping):
        pass

    class Grouping(object):
        pass

    class CurrentMetric(Mapping):
        pass

    class GetFederationTokenRequest(Mapping):
        pass

    class GetFederationTokenResponse(Mapping):
        pass

    class GetMetricDataRequest(Mapping):
        pass

    class GetMetricDataResponse(Mapping):
        pass

    class timestamp(object):
        pass

    class HistoricalMetric(Mapping):
        pass

    class ListRoutingProfilesRequest(Mapping):
        pass

    class ListRoutingProfilesResponse(Mapping):
        pass

    class ListSecurityProfilesRequest(Mapping):
        pass

    class ListSecurityProfilesResponse(Mapping):
        pass

    class ListUserHierarchyGroupsRequest(Mapping):
        pass

    class ListUserHierarchyGroupsResponse(Mapping):
        pass

    class ListUsersRequest(Mapping):
        pass

    class ListUsersResponse(Mapping):
        pass

    class StartOutboundVoiceContactRequest(Mapping):
        pass

    class StartOutboundVoiceContactResponse(Mapping):
        pass

    class Attributes(object):
        pass

    class StopContactRequest(Mapping):
        pass

    class StopContactResponse(Mapping):
        pass

    class UpdateContactAttributesRequest(Mapping):
        pass

    class UpdateContactAttributesResponse(Mapping):
        pass

    class UpdateUserHierarchyRequest(Mapping):
        pass

    class UpdateUserIdentityInfoRequest(Mapping):
        pass

    class UpdateUserPhoneConfigRequest(Mapping):
        pass

    class UpdateUserRoutingProfileRequest(Mapping):
        pass

    class UpdateUserSecurityProfilesRequest(Mapping):
        pass

    def create_user(self, InstanceId: str, RoutingProfileId: str, SecurityProfileIds: List[SecurityProfileId], PhoneConfig: UserPhoneConfig, Username: str, Password: str=None, IdentityInfo: UserIdentityInfo=None, DirectoryUserId: str=None, HierarchyGroupId: str=None) -> CreateUserResponse:
        pass

    def delete_user(self, UserId: str, InstanceId: str):
        pass

    def describe_user(self, InstanceId: str, UserId: str) -> DescribeUserResponse:
        pass

    def describe_user_hierarchy_group(self, InstanceId: str, HierarchyGroupId: str) -> DescribeUserHierarchyGroupResponse:
        pass

    def describe_user_hierarchy_structure(self, InstanceId: str) -> DescribeUserHierarchyStructureResponse:
        pass

    def get_contact_attributes(self, InitialContactId: str, InstanceId: str) -> GetContactAttributesResponse:
        pass

    def get_current_metric_data(self, CurrentMetrics: List[CurrentMetric], Filters: Filters, InstanceId: str, Groupings: List[Grouping]=None, NextToken: str=None, MaxResults: int=None) -> GetCurrentMetricDataResponse:
        pass

    def get_federation_token(self, InstanceId: str) -> GetFederationTokenResponse:
        pass

    def get_metric_data(self, HistoricalMetrics: List[HistoricalMetric], Filters: Filters, EndTime: timestamp, StartTime: timestamp, InstanceId: str, Groupings: List[Grouping]=None, NextToken: str=None, MaxResults: int=None) -> GetMetricDataResponse:
        pass

    def list_routing_profiles(self, InstanceId: str, NextToken: str=None, MaxResults: int=None) -> ListRoutingProfilesResponse:
        pass

    def list_security_profiles(self, InstanceId: str, NextToken: str=None, MaxResults: int=None) -> ListSecurityProfilesResponse:
        pass

    def list_user_hierarchy_groups(self, InstanceId: str, NextToken: str=None, MaxResults: int=None) -> ListUserHierarchyGroupsResponse:
        pass

    def list_users(self, InstanceId: str, NextToken: str=None, MaxResults: int=None) -> ListUsersResponse:
        pass

    def start_outbound_voice_contact(self, InstanceId: str, ContactFlowId: str, DestinationPhoneNumber: str, ClientToken: str=None, SourcePhoneNumber: str=None, QueueId: str=None, Attributes: Attributes=None) -> StartOutboundVoiceContactResponse:
        pass

    def stop_contact(self, InstanceId: str, ContactId: str) -> StopContactResponse:
        pass

    def update_contact_attributes(self, Attributes: Attributes, InstanceId: str, InitialContactId: str) -> UpdateContactAttributesResponse:
        pass

    def update_user_hierarchy(self, InstanceId: str, UserId: str, HierarchyGroupId: str=None):
        pass

    def update_user_identity_info(self, InstanceId: str, UserId: str, IdentityInfo: UserIdentityInfo):
        pass

    def update_user_phone_config(self, InstanceId: str, UserId: str, PhoneConfig: UserPhoneConfig):
        pass

    def update_user_routing_profile(self, InstanceId: str, UserId: str, RoutingProfileId: str):
        pass

    def update_user_security_profiles(self, InstanceId: str, UserId: str, SecurityProfileIds: List[SecurityProfileId]):
        pass


class CostandUsageReportService(BaseClient):
    class DeleteReportDefinitionRequest(Mapping):
        pass

    class DeleteReportDefinitionResponse(Mapping):
        pass

    class DescribeReportDefinitionsRequest(Mapping):
        pass

    class DescribeReportDefinitionsResponse(Mapping):
        pass

    class PutReportDefinitionRequest(Mapping):
        pass

    class PutReportDefinitionResponse(Mapping):
        pass

    class ReportDefinition(Mapping):
        pass

    def delete_report_definition(self, ReportName: str=None) -> DeleteReportDefinitionResponse:
        pass

    def describe_report_definitions(self, MaxResults: int=None, NextToken: str=None) -> DescribeReportDefinitionsResponse:
        pass

    def put_report_definition(self, ReportDefinition: ReportDefinition) -> PutReportDefinitionResponse:
        pass


class DataPipeline(BaseClient):
    class ActivatePipelineInput(Mapping):
        pass

    class ActivatePipelineOutput(Mapping):
        pass

    class ParameterValue(Mapping):
        pass

    class timestamp(object):
        pass

    class AddTagsInput(Mapping):
        pass

    class AddTagsOutput(Mapping):
        pass

    class Tag(Mapping):
        pass

    class CreatePipelineInput(Mapping):
        pass

    class CreatePipelineOutput(Mapping):
        pass

    class DeactivatePipelineInput(Mapping):
        pass

    class DeactivatePipelineOutput(Mapping):
        pass

    class cancelActive(object):
        pass

    class DeletePipelineInput(Mapping):
        pass

    class DescribeObjectsInput(Mapping):
        pass

    class DescribeObjectsOutput(Mapping):
        pass

    class id(object):
        pass

    class boolean(object):
        pass

    class DescribePipelinesInput(Mapping):
        pass

    class DescribePipelinesOutput(Mapping):
        pass

    class EvaluateExpressionInput(Mapping):
        pass

    class EvaluateExpressionOutput(Mapping):
        pass

    class GetPipelineDefinitionInput(Mapping):
        pass

    class GetPipelineDefinitionOutput(Mapping):
        pass

    class ListPipelinesInput(Mapping):
        pass

    class ListPipelinesOutput(Mapping):
        pass

    class PollForTaskInput(Mapping):
        pass

    class PollForTaskOutput(Mapping):
        pass

    class InstanceIdentity(Mapping):
        pass

    class PutPipelineDefinitionInput(Mapping):
        pass

    class PutPipelineDefinitionOutput(Mapping):
        pass

    class PipelineObject(Mapping):
        pass

    class ParameterObject(Mapping):
        pass

    class QueryObjectsInput(Mapping):
        pass

    class QueryObjectsOutput(Mapping):
        pass

    class Query(Mapping):
        pass

    class RemoveTagsInput(Mapping):
        pass

    class RemoveTagsOutput(Mapping):
        pass

    class string(object):
        pass

    class ReportTaskProgressInput(Mapping):
        pass

    class ReportTaskProgressOutput(Mapping):
        pass

    class Field(Mapping):
        pass

    class ReportTaskRunnerHeartbeatInput(Mapping):
        pass

    class ReportTaskRunnerHeartbeatOutput(Mapping):
        pass

    class SetStatusInput(Mapping):
        pass

    class SetTaskStatusInput(Mapping):
        pass

    class SetTaskStatusOutput(Mapping):
        pass

    class ValidatePipelineDefinitionInput(Mapping):
        pass

    class ValidatePipelineDefinitionOutput(Mapping):
        pass

    def activate_pipeline(self, pipelineId: str, parameterValues: List[ParameterValue]=None, startTimestamp: timestamp=None) -> ActivatePipelineOutput:
        pass

    def add_tags(self, tags: List[Tag], pipelineId: str) -> AddTagsOutput:
        pass

    def create_pipeline(self, uniqueId: str, name: str, description: str=None, tags: List[Tag]=None) -> CreatePipelineOutput:
        pass

    def deactivate_pipeline(self, pipelineId: str, cancelActive: cancelActive=None) -> DeactivatePipelineOutput:
        pass

    def delete_pipeline(self, pipelineId: str):
        pass

    def describe_objects(self, objectIds: List[id], pipelineId: str, evaluateExpressions: boolean=None, marker: str=None) -> DescribeObjectsOutput:
        pass

    def describe_pipelines(self, pipelineIds: List[id]) -> DescribePipelinesOutput:
        pass

    def evaluate_expression(self, expression: str, objectId: str, pipelineId: str) -> EvaluateExpressionOutput:
        pass

    def get_pipeline_definition(self, pipelineId: str, version: str=None) -> GetPipelineDefinitionOutput:
        pass

    def list_pipelines(self, marker: str=None) -> ListPipelinesOutput:
        pass

    def poll_for_task(self, workerGroup: str, hostname: str=None, instanceIdentity: InstanceIdentity=None) -> PollForTaskOutput:
        pass

    def put_pipeline_definition(self, pipelineObjects: List[PipelineObject], pipelineId: str, parameterObjects: List[ParameterObject]=None, parameterValues: List[ParameterValue]=None) -> PutPipelineDefinitionOutput:
        pass

    def query_objects(self, sphere: str, pipelineId: str, query: Query=None, marker: str=None, limit: int=None) -> QueryObjectsOutput:
        pass

    def remove_tags(self, tagKeys: List[string], pipelineId: str) -> RemoveTagsOutput:
        pass

    def report_task_progress(self, taskId: str, fields: List[Field]=None) -> ReportTaskProgressOutput:
        pass

    def report_task_runner_heartbeat(self, taskrunnerId: str, workerGroup: str=None, hostname: str=None) -> ReportTaskRunnerHeartbeatOutput:
        pass

    def set_status(self, status: str, objectIds: List[id], pipelineId: str):
        pass

    def set_task_status(self, taskStatus: str, taskId: str, errorId: str=None, errorMessage: str=None, errorStackTrace: str=None) -> SetTaskStatusOutput:
        pass

    def validate_pipeline_definition(self, pipelineObjects: List[PipelineObject], pipelineId: str, parameterObjects: List[ParameterObject]=None, parameterValues: List[ParameterValue]=None) -> ValidatePipelineDefinitionOutput:
        pass


class DataSync(BaseClient):
    class CancelTaskExecutionRequest(Mapping):
        pass

    class CancelTaskExecutionResponse(Mapping):
        pass

    class CreateAgentRequest(Mapping):
        pass

    class CreateAgentResponse(Mapping):
        pass

    class TagListEntry(Mapping):
        pass

    class CreateLocationEfsRequest(Mapping):
        pass

    class CreateLocationEfsResponse(Mapping):
        pass

    class Ec2Config(Mapping):
        pass

    class CreateLocationNfsRequest(Mapping):
        pass

    class CreateLocationNfsResponse(Mapping):
        pass

    class OnPremConfig(Mapping):
        pass

    class CreateLocationS3Request(Mapping):
        pass

    class CreateLocationS3Response(Mapping):
        pass

    class S3Config(Mapping):
        pass

    class CreateTaskRequest(Mapping):
        pass

    class CreateTaskResponse(Mapping):
        pass

    class Options(Mapping):
        pass

    class DeleteAgentRequest(Mapping):
        pass

    class DeleteAgentResponse(Mapping):
        pass

    class DeleteLocationRequest(Mapping):
        pass

    class DeleteLocationResponse(Mapping):
        pass

    class DeleteTaskRequest(Mapping):
        pass

    class DeleteTaskResponse(Mapping):
        pass

    class DescribeAgentRequest(Mapping):
        pass

    class DescribeAgentResponse(Mapping):
        pass

    class DescribeLocationEfsRequest(Mapping):
        pass

    class DescribeLocationEfsResponse(Mapping):
        pass

    class DescribeLocationNfsRequest(Mapping):
        pass

    class DescribeLocationNfsResponse(Mapping):
        pass

    class DescribeLocationS3Request(Mapping):
        pass

    class DescribeLocationS3Response(Mapping):
        pass

    class DescribeTaskRequest(Mapping):
        pass

    class DescribeTaskResponse(Mapping):
        pass

    class DescribeTaskExecutionRequest(Mapping):
        pass

    class DescribeTaskExecutionResponse(Mapping):
        pass

    class ListAgentsRequest(Mapping):
        pass

    class ListAgentsResponse(Mapping):
        pass

    class ListLocationsRequest(Mapping):
        pass

    class ListLocationsResponse(Mapping):
        pass

    class ListTagsForResourceRequest(Mapping):
        pass

    class ListTagsForResourceResponse(Mapping):
        pass

    class ListTaskExecutionsRequest(Mapping):
        pass

    class ListTaskExecutionsResponse(Mapping):
        pass

    class ListTasksRequest(Mapping):
        pass

    class ListTasksResponse(Mapping):
        pass

    class StartTaskExecutionRequest(Mapping):
        pass

    class StartTaskExecutionResponse(Mapping):
        pass

    class TagResourceRequest(Mapping):
        pass

    class TagResourceResponse(Mapping):
        pass

    class UntagResourceRequest(Mapping):
        pass

    class UntagResourceResponse(Mapping):
        pass

    class TagKey(object):
        pass

    class UpdateAgentRequest(Mapping):
        pass

    class UpdateAgentResponse(Mapping):
        pass

    class UpdateTaskRequest(Mapping):
        pass

    class UpdateTaskResponse(Mapping):
        pass

    def cancel_task_execution(self, TaskExecutionArn: str) -> CancelTaskExecutionResponse:
        pass

    def create_agent(self, ActivationKey: str, AgentName: str=None, Tags: List[TagListEntry]=None) -> CreateAgentResponse:
        pass

    def create_location_efs(self, Ec2Config: Ec2Config, EfsFilesystemArn: str, Subdirectory: str, Tags: List[TagListEntry]=None) -> CreateLocationEfsResponse:
        pass

    def create_location_nfs(self, OnPremConfig: OnPremConfig, ServerHostname: str, Subdirectory: str, Tags: List[TagListEntry]=None) -> CreateLocationNfsResponse:
        pass

    def create_location_s3(self, S3Config: S3Config, S3BucketArn: str, Subdirectory: str, Tags: List[TagListEntry]=None) -> CreateLocationS3Response:
        pass

    def create_task(self, DestinationLocationArn: str, SourceLocationArn: str, CloudWatchLogGroupArn: str=None, Name: str=None, Options: Options=None, Tags: List[TagListEntry]=None) -> CreateTaskResponse:
        pass

    def delete_agent(self, AgentArn: str) -> DeleteAgentResponse:
        pass

    def delete_location(self, LocationArn: str) -> DeleteLocationResponse:
        pass

    def delete_task(self, TaskArn: str) -> DeleteTaskResponse:
        pass

    def describe_agent(self, AgentArn: str) -> DescribeAgentResponse:
        pass

    def describe_location_efs(self, LocationArn: str) -> DescribeLocationEfsResponse:
        pass

    def describe_location_nfs(self, LocationArn: str) -> DescribeLocationNfsResponse:
        pass

    def describe_location_s3(self, LocationArn: str) -> DescribeLocationS3Response:
        pass

    def describe_task(self, TaskArn: str) -> DescribeTaskResponse:
        pass

    def describe_task_execution(self, TaskExecutionArn: str) -> DescribeTaskExecutionResponse:
        pass

    def list_agents(self, MaxResults: int=None, NextToken: str=None) -> ListAgentsResponse:
        pass

    def list_locations(self, MaxResults: int=None, NextToken: str=None) -> ListLocationsResponse:
        pass

    def list_tags_for_resource(self, ResourceArn: str, MaxResults: int=None, NextToken: str=None) -> ListTagsForResourceResponse:
        pass

    def list_task_executions(self, TaskArn: str=None, MaxResults: int=None, NextToken: str=None) -> ListTaskExecutionsResponse:
        pass

    def list_tasks(self, MaxResults: int=None, NextToken: str=None) -> ListTasksResponse:
        pass

    def start_task_execution(self, TaskArn: str, OverrideOptions: Options=None) -> StartTaskExecutionResponse:
        pass

    def tag_resource(self, Tags: List[TagListEntry], ResourceArn: str) -> TagResourceResponse:
        pass

    def untag_resource(self, Keys: List[TagKey], ResourceArn: str) -> UntagResourceResponse:
        pass

    def update_agent(self, AgentArn: str, Name: str=None) -> UpdateAgentResponse:
        pass

    def update_task(self, TaskArn: str, Options: Options=None, Name: str=None) -> UpdateTaskResponse:
        pass


class DAX(BaseClient):
    class CreateClusterRequest(Mapping):
        pass

    class CreateClusterResponse(Mapping):
        pass

    class String(object):
        pass

    class Tag(Mapping):
        pass

    class SSESpecification(Mapping):
        pass

    class CreateParameterGroupRequest(Mapping):
        pass

    class CreateParameterGroupResponse(Mapping):
        pass

    class CreateSubnetGroupRequest(Mapping):
        pass

    class CreateSubnetGroupResponse(Mapping):
        pass

    class DecreaseReplicationFactorRequest(Mapping):
        pass

    class DecreaseReplicationFactorResponse(Mapping):
        pass

    class DeleteClusterRequest(Mapping):
        pass

    class DeleteClusterResponse(Mapping):
        pass

    class DeleteParameterGroupRequest(Mapping):
        pass

    class DeleteParameterGroupResponse(Mapping):
        pass

    class DeleteSubnetGroupRequest(Mapping):
        pass

    class DeleteSubnetGroupResponse(Mapping):
        pass

    class DescribeClustersRequest(Mapping):
        pass

    class DescribeClustersResponse(Mapping):
        pass

    class DescribeDefaultParametersRequest(Mapping):
        pass

    class DescribeDefaultParametersResponse(Mapping):
        pass

    class DescribeEventsRequest(Mapping):
        pass

    class DescribeEventsResponse(Mapping):
        pass

    class TStamp(object):
        pass

    class DescribeParameterGroupsRequest(Mapping):
        pass

    class DescribeParameterGroupsResponse(Mapping):
        pass

    class DescribeParametersRequest(Mapping):
        pass

    class DescribeParametersResponse(Mapping):
        pass

    class DescribeSubnetGroupsRequest(Mapping):
        pass

    class DescribeSubnetGroupsResponse(Mapping):
        pass

    class IncreaseReplicationFactorRequest(Mapping):
        pass

    class IncreaseReplicationFactorResponse(Mapping):
        pass

    class ListTagsRequest(Mapping):
        pass

    class ListTagsResponse(Mapping):
        pass

    class RebootNodeRequest(Mapping):
        pass

    class RebootNodeResponse(Mapping):
        pass

    class TagResourceRequest(Mapping):
        pass

    class TagResourceResponse(Mapping):
        pass

    class UntagResourceRequest(Mapping):
        pass

    class UntagResourceResponse(Mapping):
        pass

    class UpdateClusterRequest(Mapping):
        pass

    class UpdateClusterResponse(Mapping):
        pass

    class UpdateParameterGroupRequest(Mapping):
        pass

    class UpdateParameterGroupResponse(Mapping):
        pass

    class ParameterNameValue(Mapping):
        pass

    class UpdateSubnetGroupRequest(Mapping):
        pass

    class UpdateSubnetGroupResponse(Mapping):
        pass

    def create_cluster(self, IamRoleArn: str, ReplicationFactor: int, NodeType: str, ClusterName: str, Description: str=None, AvailabilityZones: List[String]=None, SubnetGroupName: str=None, SecurityGroupIds: List[String]=None, PreferredMaintenanceWindow: str=None, NotificationTopicArn: str=None, ParameterGroupName: str=None, Tags: List[Tag]=None, SSESpecification: SSESpecification=None) -> CreateClusterResponse:
        pass

    def create_parameter_group(self, ParameterGroupName: str, Description: str=None) -> CreateParameterGroupResponse:
        pass

    def create_subnet_group(self, SubnetIds: List[String], SubnetGroupName: str, Description: str=None) -> CreateSubnetGroupResponse:
        pass

    def decrease_replication_factor(self, NewReplicationFactor: int, ClusterName: str, AvailabilityZones: List[String]=None, NodeIdsToRemove: List[String]=None) -> DecreaseReplicationFactorResponse:
        pass

    def delete_cluster(self, ClusterName: str) -> DeleteClusterResponse:
        pass

    def delete_parameter_group(self, ParameterGroupName: str) -> DeleteParameterGroupResponse:
        pass

    def delete_subnet_group(self, SubnetGroupName: str) -> DeleteSubnetGroupResponse:
        pass

    def describe_clusters(self, ClusterNames: List[String]=None, MaxResults: int=None, NextToken: str=None) -> DescribeClustersResponse:
        pass

    def describe_default_parameters(self, MaxResults: int=None, NextToken: str=None) -> DescribeDefaultParametersResponse:
        pass

    def describe_events(self, SourceName: str=None, SourceType: str=None, StartTime: TStamp=None, EndTime: TStamp=None, Duration: int=None, MaxResults: int=None, NextToken: str=None) -> DescribeEventsResponse:
        pass

    def describe_parameter_groups(self, ParameterGroupNames: List[String]=None, MaxResults: int=None, NextToken: str=None) -> DescribeParameterGroupsResponse:
        pass

    def describe_parameters(self, ParameterGroupName: str, Source: str=None, MaxResults: int=None, NextToken: str=None) -> DescribeParametersResponse:
        pass

    def describe_subnet_groups(self, SubnetGroupNames: List[String]=None, MaxResults: int=None, NextToken: str=None) -> DescribeSubnetGroupsResponse:
        pass

    def increase_replication_factor(self, NewReplicationFactor: int, ClusterName: str, AvailabilityZones: List[String]=None) -> IncreaseReplicationFactorResponse:
        pass

    def list_tags(self, ResourceName: str, NextToken: str=None) -> ListTagsResponse:
        pass

    def reboot_node(self, NodeId: str, ClusterName: str) -> RebootNodeResponse:
        pass

    def tag_resource(self, Tags: List[Tag], ResourceName: str) -> TagResourceResponse:
        pass

    def untag_resource(self, TagKeys: List[String], ResourceName: str) -> UntagResourceResponse:
        pass

    def update_cluster(self, ClusterName: str, Description: str=None, PreferredMaintenanceWindow: str=None, NotificationTopicArn: str=None, NotificationTopicStatus: str=None, ParameterGroupName: str=None, SecurityGroupIds: List[String]=None) -> UpdateClusterResponse:
        pass

    def update_parameter_group(self, ParameterNameValues: List[ParameterNameValue], ParameterGroupName: str) -> UpdateParameterGroupResponse:
        pass

    def update_subnet_group(self, SubnetGroupName: str, Description: str=None, SubnetIds: List[String]=None) -> UpdateSubnetGroupResponse:
        pass


class DeviceFarm(BaseClient):
    class CreateDevicePoolRequest(Mapping):
        pass

    class CreateDevicePoolResult(Mapping):
        pass

    class Rule(Mapping):
        pass

    class CreateInstanceProfileRequest(Mapping):
        pass

    class CreateInstanceProfileResult(Mapping):
        pass

    class Boolean(object):
        pass

    class String(object):
        pass

    class CreateNetworkProfileRequest(Mapping):
        pass

    class CreateNetworkProfileResult(Mapping):
        pass

    class Long(object):
        pass

    class CreateProjectRequest(Mapping):
        pass

    class CreateProjectResult(Mapping):
        pass

    class CreateRemoteAccessSessionRequest(Mapping):
        pass

    class CreateRemoteAccessSessionResult(Mapping):
        pass

    class CreateRemoteAccessSessionConfiguration(Mapping):
        pass

    class CreateUploadRequest(Mapping):
        pass

    class CreateUploadResult(Mapping):
        pass

    class CreateVPCEConfigurationRequest(Mapping):
        pass

    class CreateVPCEConfigurationResult(Mapping):
        pass

    class DeleteDevicePoolRequest(Mapping):
        pass

    class DeleteDevicePoolResult(Mapping):
        pass

    class DeleteInstanceProfileRequest(Mapping):
        pass

    class DeleteInstanceProfileResult(Mapping):
        pass

    class DeleteNetworkProfileRequest(Mapping):
        pass

    class DeleteNetworkProfileResult(Mapping):
        pass

    class DeleteProjectRequest(Mapping):
        pass

    class DeleteProjectResult(Mapping):
        pass

    class DeleteRemoteAccessSessionRequest(Mapping):
        pass

    class DeleteRemoteAccessSessionResult(Mapping):
        pass

    class DeleteRunRequest(Mapping):
        pass

    class DeleteRunResult(Mapping):
        pass

    class DeleteUploadRequest(Mapping):
        pass

    class DeleteUploadResult(Mapping):
        pass

    class DeleteVPCEConfigurationRequest(Mapping):
        pass

    class DeleteVPCEConfigurationResult(Mapping):
        pass

    class GetAccountSettingsRequest(Mapping):
        pass

    class GetAccountSettingsResult(Mapping):
        pass

    class GetDeviceRequest(Mapping):
        pass

    class GetDeviceResult(Mapping):
        pass

    class GetDeviceInstanceRequest(Mapping):
        pass

    class GetDeviceInstanceResult(Mapping):
        pass

    class GetDevicePoolRequest(Mapping):
        pass

    class GetDevicePoolResult(Mapping):
        pass

    class GetDevicePoolCompatibilityRequest(Mapping):
        pass

    class GetDevicePoolCompatibilityResult(Mapping):
        pass

    class ScheduleRunTest(Mapping):
        pass

    class ScheduleRunConfiguration(Mapping):
        pass

    class GetInstanceProfileRequest(Mapping):
        pass

    class GetInstanceProfileResult(Mapping):
        pass

    class GetJobRequest(Mapping):
        pass

    class GetJobResult(Mapping):
        pass

    class GetNetworkProfileRequest(Mapping):
        pass

    class GetNetworkProfileResult(Mapping):
        pass

    class GetOfferingStatusRequest(Mapping):
        pass

    class GetOfferingStatusResult(Mapping):
        pass

    class GetProjectRequest(Mapping):
        pass

    class GetProjectResult(Mapping):
        pass

    class GetRemoteAccessSessionRequest(Mapping):
        pass

    class GetRemoteAccessSessionResult(Mapping):
        pass

    class GetRunRequest(Mapping):
        pass

    class GetRunResult(Mapping):
        pass

    class GetSuiteRequest(Mapping):
        pass

    class GetSuiteResult(Mapping):
        pass

    class GetTestRequest(Mapping):
        pass

    class GetTestResult(Mapping):
        pass

    class GetUploadRequest(Mapping):
        pass

    class GetUploadResult(Mapping):
        pass

    class GetVPCEConfigurationRequest(Mapping):
        pass

    class GetVPCEConfigurationResult(Mapping):
        pass

    class InstallToRemoteAccessSessionRequest(Mapping):
        pass

    class InstallToRemoteAccessSessionResult(Mapping):
        pass

    class ListArtifactsRequest(Mapping):
        pass

    class ListArtifactsResult(Mapping):
        pass

    class ListDeviceInstancesRequest(Mapping):
        pass

    class ListDeviceInstancesResult(Mapping):
        pass

    class ListDevicePoolsRequest(Mapping):
        pass

    class ListDevicePoolsResult(Mapping):
        pass

    class ListDevicesRequest(Mapping):
        pass

    class ListDevicesResult(Mapping):
        pass

    class DeviceFilter(Mapping):
        pass

    class ListInstanceProfilesRequest(Mapping):
        pass

    class ListInstanceProfilesResult(Mapping):
        pass

    class ListJobsRequest(Mapping):
        pass

    class ListJobsResult(Mapping):
        pass

    class ListNetworkProfilesRequest(Mapping):
        pass

    class ListNetworkProfilesResult(Mapping):
        pass

    class ListOfferingPromotionsRequest(Mapping):
        pass

    class ListOfferingPromotionsResult(Mapping):
        pass

    class ListOfferingTransactionsRequest(Mapping):
        pass

    class ListOfferingTransactionsResult(Mapping):
        pass

    class ListOfferingsRequest(Mapping):
        pass

    class ListOfferingsResult(Mapping):
        pass

    class ListProjectsRequest(Mapping):
        pass

    class ListProjectsResult(Mapping):
        pass

    class ListRemoteAccessSessionsRequest(Mapping):
        pass

    class ListRemoteAccessSessionsResult(Mapping):
        pass

    class ListRunsRequest(Mapping):
        pass

    class ListRunsResult(Mapping):
        pass

    class ListSamplesRequest(Mapping):
        pass

    class ListSamplesResult(Mapping):
        pass

    class ListSuitesRequest(Mapping):
        pass

    class ListSuitesResult(Mapping):
        pass

    class ListTestsRequest(Mapping):
        pass

    class ListTestsResult(Mapping):
        pass

    class ListUniqueProblemsRequest(Mapping):
        pass

    class ListUniqueProblemsResult(Mapping):
        pass

    class ListUploadsRequest(Mapping):
        pass

    class ListUploadsResult(Mapping):
        pass

    class ListVPCEConfigurationsRequest(Mapping):
        pass

    class ListVPCEConfigurationsResult(Mapping):
        pass

    class PurchaseOfferingRequest(Mapping):
        pass

    class PurchaseOfferingResult(Mapping):
        pass

    class RenewOfferingRequest(Mapping):
        pass

    class RenewOfferingResult(Mapping):
        pass

    class ScheduleRunRequest(Mapping):
        pass

    class ScheduleRunResult(Mapping):
        pass

    class DeviceSelectionConfiguration(Mapping):
        pass

    class ExecutionConfiguration(Mapping):
        pass

    class StopJobRequest(Mapping):
        pass

    class StopJobResult(Mapping):
        pass

    class StopRemoteAccessSessionRequest(Mapping):
        pass

    class StopRemoteAccessSessionResult(Mapping):
        pass

    class StopRunRequest(Mapping):
        pass

    class StopRunResult(Mapping):
        pass

    class UpdateDeviceInstanceRequest(Mapping):
        pass

    class UpdateDeviceInstanceResult(Mapping):
        pass

    class UpdateDevicePoolRequest(Mapping):
        pass

    class UpdateDevicePoolResult(Mapping):
        pass

    class UpdateInstanceProfileRequest(Mapping):
        pass

    class UpdateInstanceProfileResult(Mapping):
        pass

    class UpdateNetworkProfileRequest(Mapping):
        pass

    class UpdateNetworkProfileResult(Mapping):
        pass

    class UpdateProjectRequest(Mapping):
        pass

    class UpdateProjectResult(Mapping):
        pass

    class UpdateUploadRequest(Mapping):
        pass

    class UpdateUploadResult(Mapping):
        pass

    class UpdateVPCEConfigurationRequest(Mapping):
        pass

    class UpdateVPCEConfigurationResult(Mapping):
        pass

    def create_device_pool(self, rules: List[Rule], name: str, projectArn: str, description: str=None, maxDevices: int=None) -> CreateDevicePoolResult:
        pass

    def create_instance_profile(self, name: str, description: str=None, packageCleanup: Boolean=None, excludeAppPackagesFromCleanup: List[String]=None, rebootAfterUse: Boolean=None) -> CreateInstanceProfileResult:
        pass

    def create_network_profile(self, name: str, projectArn: str, description: str=None, type: str=None, uplinkBandwidthBits: Long=None, downlinkBandwidthBits: Long=None, uplinkDelayMs: Long=None, downlinkDelayMs: Long=None, uplinkJitterMs: Long=None, downlinkJitterMs: Long=None, uplinkLossPercent: int=None, downlinkLossPercent: int=None) -> CreateNetworkProfileResult:
        pass

    def create_project(self, name: str, defaultJobTimeoutMinutes: int=None) -> CreateProjectResult:
        pass

    def create_remote_access_session(self, deviceArn: str, projectArn: str, instanceArn: str=None, sshPublicKey: str=None, remoteDebugEnabled: Boolean=None, remoteRecordEnabled: Boolean=None, remoteRecordAppArn: str=None, name: str=None, clientId: str=None, configuration: CreateRemoteAccessSessionConfiguration=None, interactionMode: str=None, skipAppResign: Boolean=None) -> CreateRemoteAccessSessionResult:
        pass

    def create_upload(self, type: str, name: str, projectArn: str, contentType: str=None) -> CreateUploadResult:
        pass

    def create_vpce_configuration(self, serviceDnsName: str, vpceServiceName: str, vpceConfigurationName: str, vpceConfigurationDescription: str=None) -> CreateVPCEConfigurationResult:
        pass

    def delete_device_pool(self, arn: str) -> DeleteDevicePoolResult:
        pass

    def delete_instance_profile(self, arn: str) -> DeleteInstanceProfileResult:
        pass

    def delete_network_profile(self, arn: str) -> DeleteNetworkProfileResult:
        pass

    def delete_project(self, arn: str) -> DeleteProjectResult:
        pass

    def delete_remote_access_session(self, arn: str) -> DeleteRemoteAccessSessionResult:
        pass

    def delete_run(self, arn: str) -> DeleteRunResult:
        pass

    def delete_upload(self, arn: str) -> DeleteUploadResult:
        pass

    def delete_vpce_configuration(self, arn: str) -> DeleteVPCEConfigurationResult:
        pass

    def get_account_settings(self) -> GetAccountSettingsResult:
        pass

    def get_device(self, arn: str) -> GetDeviceResult:
        pass

    def get_device_instance(self, arn: str) -> GetDeviceInstanceResult:
        pass

    def get_device_pool(self, arn: str) -> GetDevicePoolResult:
        pass

    def get_device_pool_compatibility(self, devicePoolArn: str, appArn: str=None, testType: str=None, test: ScheduleRunTest=None, configuration: ScheduleRunConfiguration=None) -> GetDevicePoolCompatibilityResult:
        pass

    def get_instance_profile(self, arn: str) -> GetInstanceProfileResult:
        pass

    def get_job(self, arn: str) -> GetJobResult:
        pass

    def get_network_profile(self, arn: str) -> GetNetworkProfileResult:
        pass

    def get_offering_status(self, nextToken: str=None) -> GetOfferingStatusResult:
        pass

    def get_project(self, arn: str) -> GetProjectResult:
        pass

    def get_remote_access_session(self, arn: str) -> GetRemoteAccessSessionResult:
        pass

    def get_run(self, arn: str) -> GetRunResult:
        pass

    def get_suite(self, arn: str) -> GetSuiteResult:
        pass

    def get_test(self, arn: str) -> GetTestResult:
        pass

    def get_upload(self, arn: str) -> GetUploadResult:
        pass

    def get_vpce_configuration(self, arn: str) -> GetVPCEConfigurationResult:
        pass

    def install_to_remote_access_session(self, appArn: str, remoteAccessSessionArn: str) -> InstallToRemoteAccessSessionResult:
        pass

    def list_artifacts(self, type: str, arn: str, nextToken: str=None) -> ListArtifactsResult:
        pass

    def list_device_instances(self, maxResults: int=None, nextToken: str=None) -> ListDeviceInstancesResult:
        pass

    def list_device_pools(self, arn: str, type: str=None, nextToken: str=None) -> ListDevicePoolsResult:
        pass

    def list_devices(self, arn: str=None, nextToken: str=None, filters: List[DeviceFilter]=None) -> ListDevicesResult:
        pass

    def list_instance_profiles(self, maxResults: int=None, nextToken: str=None) -> ListInstanceProfilesResult:
        pass

    def list_jobs(self, arn: str, nextToken: str=None) -> ListJobsResult:
        pass

    def list_network_profiles(self, arn: str, type: str=None, nextToken: str=None) -> ListNetworkProfilesResult:
        pass

    def list_offering_promotions(self, nextToken: str=None) -> ListOfferingPromotionsResult:
        pass

    def list_offering_transactions(self, nextToken: str=None) -> ListOfferingTransactionsResult:
        pass

    def list_offerings(self, nextToken: str=None) -> ListOfferingsResult:
        pass

    def list_projects(self, arn: str=None, nextToken: str=None) -> ListProjectsResult:
        pass

    def list_remote_access_sessions(self, arn: str, nextToken: str=None) -> ListRemoteAccessSessionsResult:
        pass

    def list_runs(self, arn: str, nextToken: str=None) -> ListRunsResult:
        pass

    def list_samples(self, arn: str, nextToken: str=None) -> ListSamplesResult:
        pass

    def list_suites(self, arn: str, nextToken: str=None) -> ListSuitesResult:
        pass

    def list_tests(self, arn: str, nextToken: str=None) -> ListTestsResult:
        pass

    def list_unique_problems(self, arn: str, nextToken: str=None) -> ListUniqueProblemsResult:
        pass

    def list_uploads(self, arn: str, type: str=None, nextToken: str=None) -> ListUploadsResult:
        pass

    def list_vpce_configurations(self, maxResults: int=None, nextToken: str=None) -> ListVPCEConfigurationsResult:
        pass

    def purchase_offering(self, offeringId: str=None, quantity: int=None, offeringPromotionId: str=None) -> PurchaseOfferingResult:
        pass

    def renew_offering(self, offeringId: str=None, quantity: int=None) -> RenewOfferingResult:
        pass

    def schedule_run(self, test: ScheduleRunTest, projectArn: str, appArn: str=None, devicePoolArn: str=None, deviceSelectionConfiguration: DeviceSelectionConfiguration=None, name: str=None, configuration: ScheduleRunConfiguration=None, executionConfiguration: ExecutionConfiguration=None) -> ScheduleRunResult:
        pass

    def stop_job(self, arn: str) -> StopJobResult:
        pass

    def stop_remote_access_session(self, arn: str) -> StopRemoteAccessSessionResult:
        pass

    def stop_run(self, arn: str) -> StopRunResult:
        pass

    def update_device_instance(self, arn: str, profileArn: str=None, labels: List[String]=None) -> UpdateDeviceInstanceResult:
        pass

    def update_device_pool(self, arn: str, name: str=None, description: str=None, rules: List[Rule]=None, maxDevices: int=None, clearMaxDevices: Boolean=None) -> UpdateDevicePoolResult:
        pass

    def update_instance_profile(self, arn: str, name: str=None, description: str=None, packageCleanup: Boolean=None, excludeAppPackagesFromCleanup: List[String]=None, rebootAfterUse: Boolean=None) -> UpdateInstanceProfileResult:
        pass

    def update_network_profile(self, arn: str, name: str=None, description: str=None, type: str=None, uplinkBandwidthBits: Long=None, downlinkBandwidthBits: Long=None, uplinkDelayMs: Long=None, downlinkDelayMs: Long=None, uplinkJitterMs: Long=None, downlinkJitterMs: Long=None, uplinkLossPercent: int=None, downlinkLossPercent: int=None) -> UpdateNetworkProfileResult:
        pass

    def update_project(self, arn: str, name: str=None, defaultJobTimeoutMinutes: int=None) -> UpdateProjectResult:
        pass

    def update_upload(self, arn: str, name: str=None, contentType: str=None, editContent: Boolean=None) -> UpdateUploadResult:
        pass

    def update_vpce_configuration(self, arn: str, vpceConfigurationName: str=None, vpceServiceName: str=None, serviceDnsName: str=None, vpceConfigurationDescription: str=None) -> UpdateVPCEConfigurationResult:
        pass


class DirectConnect(BaseClient):
    class AllocateConnectionOnInterconnectRequest(Mapping):
        pass

    class Connection(Mapping):
        pass

    class AllocateHostedConnectionRequest(Mapping):
        pass

    class AllocatePrivateVirtualInterfaceRequest(Mapping):
        pass

    class VirtualInterface(Mapping):
        pass

    class NewPrivateVirtualInterfaceAllocation(Mapping):
        pass

    class AllocatePublicVirtualInterfaceRequest(Mapping):
        pass

    class NewPublicVirtualInterfaceAllocation(Mapping):
        pass

    class AssociateConnectionWithLagRequest(Mapping):
        pass

    class AssociateHostedConnectionRequest(Mapping):
        pass

    class AssociateVirtualInterfaceRequest(Mapping):
        pass

    class ConfirmConnectionRequest(Mapping):
        pass

    class ConfirmConnectionResponse(Mapping):
        pass

    class ConfirmPrivateVirtualInterfaceRequest(Mapping):
        pass

    class ConfirmPrivateVirtualInterfaceResponse(Mapping):
        pass

    class ConfirmPublicVirtualInterfaceRequest(Mapping):
        pass

    class ConfirmPublicVirtualInterfaceResponse(Mapping):
        pass

    class CreateBGPPeerRequest(Mapping):
        pass

    class CreateBGPPeerResponse(Mapping):
        pass

    class NewBGPPeer(Mapping):
        pass

    class CreateConnectionRequest(Mapping):
        pass

    class CreateDirectConnectGatewayRequest(Mapping):
        pass

    class CreateDirectConnectGatewayResult(Mapping):
        pass

    class LongAsn(object):
        pass

    class CreateDirectConnectGatewayAssociationRequest(Mapping):
        pass

    class CreateDirectConnectGatewayAssociationResult(Mapping):
        pass

    class CreateInterconnectRequest(Mapping):
        pass

    class Interconnect(Mapping):
        pass

    class CreateLagRequest(Mapping):
        pass

    class Lag(Mapping):
        pass

    class CreatePrivateVirtualInterfaceRequest(Mapping):
        pass

    class NewPrivateVirtualInterface(Mapping):
        pass

    class CreatePublicVirtualInterfaceRequest(Mapping):
        pass

    class NewPublicVirtualInterface(Mapping):
        pass

    class DeleteBGPPeerRequest(Mapping):
        pass

    class DeleteBGPPeerResponse(Mapping):
        pass

    class DeleteConnectionRequest(Mapping):
        pass

    class DeleteDirectConnectGatewayRequest(Mapping):
        pass

    class DeleteDirectConnectGatewayResult(Mapping):
        pass

    class DeleteDirectConnectGatewayAssociationRequest(Mapping):
        pass

    class DeleteDirectConnectGatewayAssociationResult(Mapping):
        pass

    class DeleteInterconnectRequest(Mapping):
        pass

    class DeleteInterconnectResponse(Mapping):
        pass

    class DeleteLagRequest(Mapping):
        pass

    class DeleteVirtualInterfaceRequest(Mapping):
        pass

    class DeleteVirtualInterfaceResponse(Mapping):
        pass

    class DescribeConnectionLoaRequest(Mapping):
        pass

    class DescribeConnectionLoaResponse(Mapping):
        pass

    class DescribeConnectionsRequest(Mapping):
        pass

    class Connections(Mapping):
        pass

    class DescribeConnectionsOnInterconnectRequest(Mapping):
        pass

    class DescribeDirectConnectGatewayAssociationsRequest(Mapping):
        pass

    class DescribeDirectConnectGatewayAssociationsResult(Mapping):
        pass

    class DescribeDirectConnectGatewayAttachmentsRequest(Mapping):
        pass

    class DescribeDirectConnectGatewayAttachmentsResult(Mapping):
        pass

    class DescribeDirectConnectGatewaysRequest(Mapping):
        pass

    class DescribeDirectConnectGatewaysResult(Mapping):
        pass

    class DescribeHostedConnectionsRequest(Mapping):
        pass

    class DescribeInterconnectLoaRequest(Mapping):
        pass

    class DescribeInterconnectLoaResponse(Mapping):
        pass

    class DescribeInterconnectsRequest(Mapping):
        pass

    class Interconnects(Mapping):
        pass

    class DescribeLagsRequest(Mapping):
        pass

    class Lags(Mapping):
        pass

    class DescribeLoaRequest(Mapping):
        pass

    class Loa(Mapping):
        pass

    class Locations(Mapping):
        pass

    class DescribeTagsRequest(Mapping):
        pass

    class DescribeTagsResponse(Mapping):
        pass

    class ResourceArn(object):
        pass

    class VirtualGateways(Mapping):
        pass

    class DescribeVirtualInterfacesRequest(Mapping):
        pass

    class VirtualInterfaces(Mapping):
        pass

    class DisassociateConnectionFromLagRequest(Mapping):
        pass

    class TagResourceRequest(Mapping):
        pass

    class TagResourceResponse(Mapping):
        pass

    class Tag(Mapping):
        pass

    class UntagResourceRequest(Mapping):
        pass

    class UntagResourceResponse(Mapping):
        pass

    class TagKey(object):
        pass

    class UpdateLagRequest(Mapping):
        pass

    class UpdateVirtualInterfaceAttributesRequest(Mapping):
        pass

    def allocate_connection_on_interconnect(self, vlan: int, interconnectId: str, ownerAccount: str, connectionName: str, bandwidth: str) -> Connection:
        pass

    def allocate_hosted_connection(self, vlan: int, connectionName: str, bandwidth: str, ownerAccount: str, connectionId: str) -> Connection:
        pass

    def allocate_private_virtual_interface(self, newPrivateVirtualInterfaceAllocation: NewPrivateVirtualInterfaceAllocation, ownerAccount: str, connectionId: str) -> VirtualInterface:
        pass

    def allocate_public_virtual_interface(self, newPublicVirtualInterfaceAllocation: NewPublicVirtualInterfaceAllocation, ownerAccount: str, connectionId: str) -> VirtualInterface:
        pass

    def associate_connection_with_lag(self, lagId: str, connectionId: str) -> Connection:
        pass

    def associate_hosted_connection(self, parentConnectionId: str, connectionId: str) -> Connection:
        pass

    def associate_virtual_interface(self, connectionId: str, virtualInterfaceId: str) -> VirtualInterface:
        pass

    def confirm_connection(self, connectionId: str) -> ConfirmConnectionResponse:
        pass

    def confirm_private_virtual_interface(self, virtualInterfaceId: str, virtualGatewayId: str=None, directConnectGatewayId: str=None) -> ConfirmPrivateVirtualInterfaceResponse:
        pass

    def confirm_public_virtual_interface(self, virtualInterfaceId: str) -> ConfirmPublicVirtualInterfaceResponse:
        pass

    def create_bgp_peer(self, virtualInterfaceId: str=None, newBGPPeer: NewBGPPeer=None) -> CreateBGPPeerResponse:
        pass

    def create_connection(self, connectionName: str, bandwidth: str, location: str, lagId: str=None) -> Connection:
        pass

    def create_direct_connect_gateway(self, directConnectGatewayName: str, amazonSideAsn: LongAsn=None) -> CreateDirectConnectGatewayResult:
        pass

    def create_direct_connect_gateway_association(self, virtualGatewayId: str, directConnectGatewayId: str) -> CreateDirectConnectGatewayAssociationResult:
        pass

    def create_interconnect(self, location: str, bandwidth: str, interconnectName: str, lagId: str=None) -> Interconnect:
        pass

    def create_lag(self, lagName: str, connectionsBandwidth: str, location: str, numberOfConnections: int, connectionId: str=None) -> Lag:
        pass

    def create_private_virtual_interface(self, newPrivateVirtualInterface: NewPrivateVirtualInterface, connectionId: str) -> VirtualInterface:
        pass

    def create_public_virtual_interface(self, newPublicVirtualInterface: NewPublicVirtualInterface, connectionId: str) -> VirtualInterface:
        pass

    def delete_bgp_peer(self, virtualInterfaceId: str=None, asn: int=None, customerAddress: str=None, bgpPeerId: str=None) -> DeleteBGPPeerResponse:
        pass

    def delete_connection(self, connectionId: str) -> Connection:
        pass

    def delete_direct_connect_gateway(self, directConnectGatewayId: str) -> DeleteDirectConnectGatewayResult:
        pass

    def delete_direct_connect_gateway_association(self, virtualGatewayId: str, directConnectGatewayId: str) -> DeleteDirectConnectGatewayAssociationResult:
        pass

    def delete_interconnect(self, interconnectId: str) -> DeleteInterconnectResponse:
        pass

    def delete_lag(self, lagId: str) -> Lag:
        pass

    def delete_virtual_interface(self, virtualInterfaceId: str) -> DeleteVirtualInterfaceResponse:
        pass

    def describe_connection_loa(self, connectionId: str, providerName: str=None, loaContentType: str=None) -> DescribeConnectionLoaResponse:
        pass

    def describe_connections(self, connectionId: str=None) -> Connections:
        pass

    def describe_connections_on_interconnect(self, interconnectId: str) -> Connections:
        pass

    def describe_direct_connect_gateway_associations(self, directConnectGatewayId: str=None, virtualGatewayId: str=None, maxResults: int=None, nextToken: str=None) -> DescribeDirectConnectGatewayAssociationsResult:
        pass

    def describe_direct_connect_gateway_attachments(self, directConnectGatewayId: str=None, virtualInterfaceId: str=None, maxResults: int=None, nextToken: str=None) -> DescribeDirectConnectGatewayAttachmentsResult:
        pass

    def describe_direct_connect_gateways(self, directConnectGatewayId: str=None, maxResults: int=None, nextToken: str=None) -> DescribeDirectConnectGatewaysResult:
        pass

    def describe_hosted_connections(self, connectionId: str) -> Connections:
        pass

    def describe_interconnect_loa(self, interconnectId: str, providerName: str=None, loaContentType: str=None) -> DescribeInterconnectLoaResponse:
        pass

    def describe_interconnects(self, interconnectId: str=None) -> Interconnects:
        pass

    def describe_lags(self, lagId: str=None) -> Lags:
        pass

    def describe_loa(self, connectionId: str, providerName: str=None, loaContentType: str=None) -> Loa:
        pass

    def describe_locations(self) -> Locations:
        pass

    def describe_tags(self, resourceArns: List[ResourceArn]) -> DescribeTagsResponse:
        pass

    def describe_virtual_gateways(self) -> VirtualGateways:
        pass

    def describe_virtual_interfaces(self, connectionId: str=None, virtualInterfaceId: str=None) -> VirtualInterfaces:
        pass

    def disassociate_connection_from_lag(self, lagId: str, connectionId: str) -> Connection:
        pass

    def tag_resource(self, tags: List[Tag], resourceArn: str) -> TagResourceResponse:
        pass

    def untag_resource(self, tagKeys: List[TagKey], resourceArn: str) -> UntagResourceResponse:
        pass

    def update_lag(self, lagId: str, lagName: str=None, minimumLinks: int=None) -> Lag:
        pass

    def update_virtual_interface_attributes(self, virtualInterfaceId: str, mtu: int=None) -> VirtualInterface:
        pass


class ApplicationDiscoveryService(BaseClient):
    class AssociateConfigurationItemsToApplicationRequest(Mapping):
        pass

    class AssociateConfigurationItemsToApplicationResponse(Mapping):
        pass

    class ConfigurationId(object):
        pass

    class BatchDeleteImportDataRequest(Mapping):
        pass

    class BatchDeleteImportDataResponse(Mapping):
        pass

    class ImportTaskIdentifier(object):
        pass

    class CreateApplicationRequest(Mapping):
        pass

    class CreateApplicationResponse(Mapping):
        pass

    class CreateTagsRequest(Mapping):
        pass

    class CreateTagsResponse(Mapping):
        pass

    class Tag(Mapping):
        pass

    class DeleteApplicationsRequest(Mapping):
        pass

    class DeleteApplicationsResponse(Mapping):
        pass

    class ApplicationId(object):
        pass

    class DeleteTagsRequest(Mapping):
        pass

    class DeleteTagsResponse(Mapping):
        pass

    class DescribeAgentsRequest(Mapping):
        pass

    class DescribeAgentsResponse(Mapping):
        pass

    class AgentId(object):
        pass

    class Filter(Mapping):
        pass

    class DescribeConfigurationsRequest(Mapping):
        pass

    class DescribeConfigurationsResponse(Mapping):
        pass

    class DescribeContinuousExportsRequest(Mapping):
        pass

    class DescribeContinuousExportsResponse(Mapping):
        pass

    class ConfigurationsExportId(object):
        pass

    class DescribeExportConfigurationsRequest(Mapping):
        pass

    class DescribeExportConfigurationsResponse(Mapping):
        pass

    class DescribeExportTasksRequest(Mapping):
        pass

    class DescribeExportTasksResponse(Mapping):
        pass

    class ExportFilter(Mapping):
        pass

    class DescribeImportTasksRequest(Mapping):
        pass

    class DescribeImportTasksResponse(Mapping):
        pass

    class ImportTaskFilter(Mapping):
        pass

    class DescribeTagsRequest(Mapping):
        pass

    class DescribeTagsResponse(Mapping):
        pass

    class TagFilter(Mapping):
        pass

    class DisassociateConfigurationItemsFromApplicationRequest(Mapping):
        pass

    class DisassociateConfigurationItemsFromApplicationResponse(Mapping):
        pass

    class ExportConfigurationsResponse(Mapping):
        pass

    class GetDiscoverySummaryRequest(Mapping):
        pass

    class GetDiscoverySummaryResponse(Mapping):
        pass

    class ListConfigurationsRequest(Mapping):
        pass

    class ListConfigurationsResponse(Mapping):
        pass

    class OrderByElement(Mapping):
        pass

    class ListServerNeighborsRequest(Mapping):
        pass

    class ListServerNeighborsResponse(Mapping):
        pass

    class Boolean(object):
        pass

    class StartContinuousExportRequest(Mapping):
        pass

    class StartContinuousExportResponse(Mapping):
        pass

    class StartDataCollectionByAgentIdsRequest(Mapping):
        pass

    class StartDataCollectionByAgentIdsResponse(Mapping):
        pass

    class StartExportTaskRequest(Mapping):
        pass

    class StartExportTaskResponse(Mapping):
        pass

    class ExportDataFormat(object):
        pass

    class TimeStamp(object):
        pass

    class StartImportTaskRequest(Mapping):
        pass

    class StartImportTaskResponse(Mapping):
        pass

    class StopContinuousExportRequest(Mapping):
        pass

    class StopContinuousExportResponse(Mapping):
        pass

    class StopDataCollectionByAgentIdsRequest(Mapping):
        pass

    class StopDataCollectionByAgentIdsResponse(Mapping):
        pass

    class UpdateApplicationRequest(Mapping):
        pass

    class UpdateApplicationResponse(Mapping):
        pass

    def associate_configuration_items_to_application(self, configurationIds: List[ConfigurationId], applicationConfigurationId: str) -> AssociateConfigurationItemsToApplicationResponse:
        pass

    def batch_delete_import_data(self, importTaskIds: List[ImportTaskIdentifier]) -> BatchDeleteImportDataResponse:
        pass

    def create_application(self, name: str, description: str=None) -> CreateApplicationResponse:
        pass

    def create_tags(self, tags: List[Tag], configurationIds: List[ConfigurationId]) -> CreateTagsResponse:
        pass

    def delete_applications(self, configurationIds: List[ApplicationId]) -> DeleteApplicationsResponse:
        pass

    def delete_tags(self, configurationIds: List[ConfigurationId], tags: List[Tag]=None) -> DeleteTagsResponse:
        pass

    def describe_agents(self, agentIds: List[AgentId]=None, filters: List[Filter]=None, maxResults: int=None, nextToken: str=None) -> DescribeAgentsResponse:
        pass

    def describe_configurations(self, configurationIds: List[ConfigurationId]) -> DescribeConfigurationsResponse:
        pass

    def describe_continuous_exports(self, exportIds: List[ConfigurationsExportId]=None, maxResults: int=None, nextToken: str=None) -> DescribeContinuousExportsResponse:
        pass

    def describe_export_configurations(self, exportIds: List[ConfigurationsExportId]=None, maxResults: int=None, nextToken: str=None) -> DescribeExportConfigurationsResponse:
        pass

    def describe_export_tasks(self, exportIds: List[ConfigurationsExportId]=None, filters: List[ExportFilter]=None, maxResults: int=None, nextToken: str=None) -> DescribeExportTasksResponse:
        pass

    def describe_import_tasks(self, filters: List[ImportTaskFilter]=None, maxResults: int=None, nextToken: str=None) -> DescribeImportTasksResponse:
        pass

    def describe_tags(self, filters: List[TagFilter]=None, maxResults: int=None, nextToken: str=None) -> DescribeTagsResponse:
        pass

    def disassociate_configuration_items_from_application(self, configurationIds: List[ConfigurationId], applicationConfigurationId: str) -> DisassociateConfigurationItemsFromApplicationResponse:
        pass

    def export_configurations(self) -> ExportConfigurationsResponse:
        pass

    def get_discovery_summary(self) -> GetDiscoverySummaryResponse:
        pass

    def list_configurations(self, configurationType: str, filters: List[Filter]=None, maxResults: int=None, nextToken: str=None, orderBy: List[OrderByElement]=None) -> ListConfigurationsResponse:
        pass

    def list_server_neighbors(self, configurationId: str, portInformationNeeded: Boolean=None, neighborConfigurationIds: List[ConfigurationId]=None, maxResults: int=None, nextToken: str=None) -> ListServerNeighborsResponse:
        pass

    def start_continuous_export(self) -> StartContinuousExportResponse:
        pass

    def start_data_collection_by_agent_ids(self, agentIds: List[AgentId]) -> StartDataCollectionByAgentIdsResponse:
        pass

    def start_export_task(self, exportDataFormat: List[ExportDataFormat]=None, filters: List[ExportFilter]=None, startTime: TimeStamp=None, endTime: TimeStamp=None) -> StartExportTaskResponse:
        pass

    def start_import_task(self, importUrl: str, name: str, clientRequestToken: str=None) -> StartImportTaskResponse:
        pass

    def stop_continuous_export(self, exportId: str) -> StopContinuousExportResponse:
        pass

    def stop_data_collection_by_agent_ids(self, agentIds: List[AgentId]) -> StopDataCollectionByAgentIdsResponse:
        pass

    def update_application(self, configurationId: str, name: str=None, description: str=None) -> UpdateApplicationResponse:
        pass


class DLM(BaseClient):
    class CreateLifecyclePolicyRequest(Mapping):
        pass

    class CreateLifecyclePolicyResponse(Mapping):
        pass

    class PolicyDetails(Mapping):
        pass

    class DeleteLifecyclePolicyRequest(Mapping):
        pass

    class DeleteLifecyclePolicyResponse(Mapping):
        pass

    class GetLifecyclePoliciesRequest(Mapping):
        pass

    class GetLifecyclePoliciesResponse(Mapping):
        pass

    class PolicyId(object):
        pass

    class ResourceTypeValues(object):
        pass

    class TagFilter(object):
        pass

    class GetLifecyclePolicyRequest(Mapping):
        pass

    class GetLifecyclePolicyResponse(Mapping):
        pass

    class UpdateLifecyclePolicyRequest(Mapping):
        pass

    class UpdateLifecyclePolicyResponse(Mapping):
        pass

    def create_lifecycle_policy(self, PolicyDetails: PolicyDetails, State: str, Description: str, ExecutionRoleArn: str) -> CreateLifecyclePolicyResponse:
        pass

    def delete_lifecycle_policy(self, PolicyId: str) -> DeleteLifecyclePolicyResponse:
        pass

    def get_lifecycle_policies(self, PolicyIds: List[PolicyId]=None, State: str=None, ResourceTypes: List[ResourceTypeValues]=None, TargetTags: List[TagFilter]=None, TagsToAdd: List[TagFilter]=None) -> GetLifecyclePoliciesResponse:
        pass

    def get_lifecycle_policy(self, PolicyId: str) -> GetLifecyclePolicyResponse:
        pass

    def update_lifecycle_policy(self, PolicyId: str, ExecutionRoleArn: str=None, State: str=None, Description: str=None, PolicyDetails: PolicyDetails=None) -> UpdateLifecyclePolicyResponse:
        pass


class DatabaseMigrationService(BaseClient):
    class AddTagsToResourceMessage(Mapping):
        pass

    class AddTagsToResourceResponse(Mapping):
        pass

    class Tag(Mapping):
        pass

    class CreateEndpointMessage(Mapping):
        pass

    class CreateEndpointResponse(Mapping):
        pass

    class DynamoDbSettings(Mapping):
        pass

    class S3Settings(Mapping):
        pass

    class DmsTransferSettings(Mapping):
        pass

    class MongoDbSettings(Mapping):
        pass

    class KinesisSettings(Mapping):
        pass

    class ElasticsearchSettings(Mapping):
        pass

    class CreateEventSubscriptionMessage(Mapping):
        pass

    class CreateEventSubscriptionResponse(Mapping):
        pass

    class String(object):
        pass

    class BooleanOptional(object):
        pass

    class CreateReplicationInstanceMessage(Mapping):
        pass

    class CreateReplicationInstanceResponse(Mapping):
        pass

    class CreateReplicationSubnetGroupMessage(Mapping):
        pass

    class CreateReplicationSubnetGroupResponse(Mapping):
        pass

    class CreateReplicationTaskMessage(Mapping):
        pass

    class CreateReplicationTaskResponse(Mapping):
        pass

    class TStamp(object):
        pass

    class DeleteCertificateMessage(Mapping):
        pass

    class DeleteCertificateResponse(Mapping):
        pass

    class DeleteEndpointMessage(Mapping):
        pass

    class DeleteEndpointResponse(Mapping):
        pass

    class DeleteEventSubscriptionMessage(Mapping):
        pass

    class DeleteEventSubscriptionResponse(Mapping):
        pass

    class DeleteReplicationInstanceMessage(Mapping):
        pass

    class DeleteReplicationInstanceResponse(Mapping):
        pass

    class DeleteReplicationSubnetGroupMessage(Mapping):
        pass

    class DeleteReplicationSubnetGroupResponse(Mapping):
        pass

    class DeleteReplicationTaskMessage(Mapping):
        pass

    class DeleteReplicationTaskResponse(Mapping):
        pass

    class DescribeAccountAttributesMessage(Mapping):
        pass

    class DescribeAccountAttributesResponse(Mapping):
        pass

    class DescribeCertificatesMessage(Mapping):
        pass

    class DescribeCertificatesResponse(Mapping):
        pass

    class Filter(Mapping):
        pass

    class DescribeConnectionsMessage(Mapping):
        pass

    class DescribeConnectionsResponse(Mapping):
        pass

    class DescribeEndpointTypesMessage(Mapping):
        pass

    class DescribeEndpointTypesResponse(Mapping):
        pass

    class DescribeEndpointsMessage(Mapping):
        pass

    class DescribeEndpointsResponse(Mapping):
        pass

    class DescribeEventCategoriesMessage(Mapping):
        pass

    class DescribeEventCategoriesResponse(Mapping):
        pass

    class DescribeEventSubscriptionsMessage(Mapping):
        pass

    class DescribeEventSubscriptionsResponse(Mapping):
        pass

    class DescribeEventsMessage(Mapping):
        pass

    class DescribeEventsResponse(Mapping):
        pass

    class DescribeOrderableReplicationInstancesMessage(Mapping):
        pass

    class DescribeOrderableReplicationInstancesResponse(Mapping):
        pass

    class DescribeRefreshSchemasStatusMessage(Mapping):
        pass

    class DescribeRefreshSchemasStatusResponse(Mapping):
        pass

    class DescribeReplicationInstanceTaskLogsMessage(Mapping):
        pass

    class DescribeReplicationInstanceTaskLogsResponse(Mapping):
        pass

    class DescribeReplicationInstancesMessage(Mapping):
        pass

    class DescribeReplicationInstancesResponse(Mapping):
        pass

    class DescribeReplicationSubnetGroupsMessage(Mapping):
        pass

    class DescribeReplicationSubnetGroupsResponse(Mapping):
        pass

    class DescribeReplicationTaskAssessmentResultsMessage(Mapping):
        pass

    class DescribeReplicationTaskAssessmentResultsResponse(Mapping):
        pass

    class DescribeReplicationTasksMessage(Mapping):
        pass

    class DescribeReplicationTasksResponse(Mapping):
        pass

    class DescribeSchemasMessage(Mapping):
        pass

    class DescribeSchemasResponse(Mapping):
        pass

    class DescribeTableStatisticsMessage(Mapping):
        pass

    class DescribeTableStatisticsResponse(Mapping):
        pass

    class ImportCertificateMessage(Mapping):
        pass

    class ImportCertificateResponse(Mapping):
        pass

    class CertificateWallet(object):
        pass

    class ListTagsForResourceMessage(Mapping):
        pass

    class ListTagsForResourceResponse(Mapping):
        pass

    class ModifyEndpointMessage(Mapping):
        pass

    class ModifyEndpointResponse(Mapping):
        pass

    class ModifyEventSubscriptionMessage(Mapping):
        pass

    class ModifyEventSubscriptionResponse(Mapping):
        pass

    class ModifyReplicationInstanceMessage(Mapping):
        pass

    class ModifyReplicationInstanceResponse(Mapping):
        pass

    class Boolean(object):
        pass

    class ModifyReplicationSubnetGroupMessage(Mapping):
        pass

    class ModifyReplicationSubnetGroupResponse(Mapping):
        pass

    class ModifyReplicationTaskMessage(Mapping):
        pass

    class ModifyReplicationTaskResponse(Mapping):
        pass

    class RebootReplicationInstanceMessage(Mapping):
        pass

    class RebootReplicationInstanceResponse(Mapping):
        pass

    class RefreshSchemasMessage(Mapping):
        pass

    class RefreshSchemasResponse(Mapping):
        pass

    class ReloadTablesMessage(Mapping):
        pass

    class ReloadTablesResponse(Mapping):
        pass

    class TableToReload(Mapping):
        pass

    class RemoveTagsFromResourceMessage(Mapping):
        pass

    class RemoveTagsFromResourceResponse(Mapping):
        pass

    class StartReplicationTaskMessage(Mapping):
        pass

    class StartReplicationTaskResponse(Mapping):
        pass

    class StartReplicationTaskAssessmentMessage(Mapping):
        pass

    class StartReplicationTaskAssessmentResponse(Mapping):
        pass

    class StopReplicationTaskMessage(Mapping):
        pass

    class StopReplicationTaskResponse(Mapping):
        pass

    class TestConnectionMessage(Mapping):
        pass

    class TestConnectionResponse(Mapping):
        pass

    def add_tags_to_resource(self, Tags: List[Tag], ResourceArn: str) -> AddTagsToResourceResponse:
        pass

    def create_endpoint(self, EngineName: str, EndpointType: str, EndpointIdentifier: str, Username: str=None, Password: str=None, ServerName: str=None, Port: int=None, DatabaseName: str=None, ExtraConnectionAttributes: str=None, KmsKeyId: str=None, Tags: List[Tag]=None, CertificateArn: str=None, SslMode: str=None, ServiceAccessRoleArn: str=None, ExternalTableDefinition: str=None, DynamoDbSettings: DynamoDbSettings=None, S3Settings: S3Settings=None, DmsTransferSettings: DmsTransferSettings=None, MongoDbSettings: MongoDbSettings=None, KinesisSettings: KinesisSettings=None, ElasticsearchSettings: ElasticsearchSettings=None) -> CreateEndpointResponse:
        pass

    def create_event_subscription(self, SnsTopicArn: str, SubscriptionName: str, SourceType: str=None, EventCategories: List[String]=None, SourceIds: List[String]=None, Enabled: BooleanOptional=None, Tags: List[Tag]=None) -> CreateEventSubscriptionResponse:
        pass

    def create_replication_instance(self, ReplicationInstanceClass: str, ReplicationInstanceIdentifier: str, AllocatedStorage: int=None, VpcSecurityGroupIds: List[String]=None, AvailabilityZone: str=None, ReplicationSubnetGroupIdentifier: str=None, PreferredMaintenanceWindow: str=None, MultiAZ: BooleanOptional=None, EngineVersion: str=None, AutoMinorVersionUpgrade: BooleanOptional=None, Tags: List[Tag]=None, KmsKeyId: str=None, PubliclyAccessible: BooleanOptional=None, DnsNameServers: str=None) -> CreateReplicationInstanceResponse:
        pass

    def create_replication_subnet_group(self, SubnetIds: List[String], ReplicationSubnetGroupDescription: str, ReplicationSubnetGroupIdentifier: str, Tags: List[Tag]=None) -> CreateReplicationSubnetGroupResponse:
        pass

    def create_replication_task(self, TableMappings: str, MigrationType: str, ReplicationInstanceArn: str, TargetEndpointArn: str, SourceEndpointArn: str, ReplicationTaskIdentifier: str, ReplicationTaskSettings: str=None, CdcStartTime: TStamp=None, CdcStartPosition: str=None, CdcStopPosition: str=None, Tags: List[Tag]=None) -> CreateReplicationTaskResponse:
        pass

    def delete_certificate(self, CertificateArn: str) -> DeleteCertificateResponse:
        pass

    def delete_endpoint(self, EndpointArn: str) -> DeleteEndpointResponse:
        pass

    def delete_event_subscription(self, SubscriptionName: str) -> DeleteEventSubscriptionResponse:
        pass

    def delete_replication_instance(self, ReplicationInstanceArn: str) -> DeleteReplicationInstanceResponse:
        pass

    def delete_replication_subnet_group(self, ReplicationSubnetGroupIdentifier: str) -> DeleteReplicationSubnetGroupResponse:
        pass

    def delete_replication_task(self, ReplicationTaskArn: str) -> DeleteReplicationTaskResponse:
        pass

    def describe_account_attributes(self) -> DescribeAccountAttributesResponse:
        pass

    def describe_certificates(self, Filters: List[Filter]=None, MaxRecords: int=None, Marker: str=None) -> DescribeCertificatesResponse:
        pass

    def describe_connections(self, Filters: List[Filter]=None, MaxRecords: int=None, Marker: str=None) -> DescribeConnectionsResponse:
        pass

    def describe_endpoint_types(self, Filters: List[Filter]=None, MaxRecords: int=None, Marker: str=None) -> DescribeEndpointTypesResponse:
        pass

    def describe_endpoints(self, Filters: List[Filter]=None, MaxRecords: int=None, Marker: str=None) -> DescribeEndpointsResponse:
        pass

    def describe_event_categories(self, SourceType: str=None, Filters: List[Filter]=None) -> DescribeEventCategoriesResponse:
        pass

    def describe_event_subscriptions(self, SubscriptionName: str=None, Filters: List[Filter]=None, MaxRecords: int=None, Marker: str=None) -> DescribeEventSubscriptionsResponse:
        pass

    def describe_events(self, SourceIdentifier: str=None, SourceType: str=None, StartTime: TStamp=None, EndTime: TStamp=None, Duration: int=None, EventCategories: List[String]=None, Filters: List[Filter]=None, MaxRecords: int=None, Marker: str=None) -> DescribeEventsResponse:
        pass

    def describe_orderable_replication_instances(self, MaxRecords: int=None, Marker: str=None) -> DescribeOrderableReplicationInstancesResponse:
        pass

    def describe_refresh_schemas_status(self, EndpointArn: str) -> DescribeRefreshSchemasStatusResponse:
        pass

    def describe_replication_instance_task_logs(self, ReplicationInstanceArn: str, MaxRecords: int=None, Marker: str=None) -> DescribeReplicationInstanceTaskLogsResponse:
        pass

    def describe_replication_instances(self, Filters: List[Filter]=None, MaxRecords: int=None, Marker: str=None) -> DescribeReplicationInstancesResponse:
        pass

    def describe_replication_subnet_groups(self, Filters: List[Filter]=None, MaxRecords: int=None, Marker: str=None) -> DescribeReplicationSubnetGroupsResponse:
        pass

    def describe_replication_task_assessment_results(self, ReplicationTaskArn: str=None, MaxRecords: int=None, Marker: str=None) -> DescribeReplicationTaskAssessmentResultsResponse:
        pass

    def describe_replication_tasks(self, Filters: List[Filter]=None, MaxRecords: int=None, Marker: str=None) -> DescribeReplicationTasksResponse:
        pass

    def describe_schemas(self, EndpointArn: str, MaxRecords: int=None, Marker: str=None) -> DescribeSchemasResponse:
        pass

    def describe_table_statistics(self, ReplicationTaskArn: str, MaxRecords: int=None, Marker: str=None, Filters: List[Filter]=None) -> DescribeTableStatisticsResponse:
        pass

    def import_certificate(self, CertificateIdentifier: str, CertificatePem: str=None, CertificateWallet: CertificateWallet=None, Tags: List[Tag]=None) -> ImportCertificateResponse:
        pass

    def list_tags_for_resource(self, ResourceArn: str) -> ListTagsForResourceResponse:
        pass

    def modify_endpoint(self, EndpointArn: str, EndpointIdentifier: str=None, EndpointType: str=None, EngineName: str=None, Username: str=None, Password: str=None, ServerName: str=None, Port: int=None, DatabaseName: str=None, ExtraConnectionAttributes: str=None, CertificateArn: str=None, SslMode: str=None, ServiceAccessRoleArn: str=None, ExternalTableDefinition: str=None, DynamoDbSettings: DynamoDbSettings=None, S3Settings: S3Settings=None, DmsTransferSettings: DmsTransferSettings=None, MongoDbSettings: MongoDbSettings=None, KinesisSettings: KinesisSettings=None, ElasticsearchSettings: ElasticsearchSettings=None) -> ModifyEndpointResponse:
        pass

    def modify_event_subscription(self, SubscriptionName: str, SnsTopicArn: str=None, SourceType: str=None, EventCategories: List[String]=None, Enabled: BooleanOptional=None) -> ModifyEventSubscriptionResponse:
        pass

    def modify_replication_instance(self, ReplicationInstanceArn: str, AllocatedStorage: int=None, ApplyImmediately: Boolean=None, ReplicationInstanceClass: str=None, VpcSecurityGroupIds: List[String]=None, PreferredMaintenanceWindow: str=None, MultiAZ: BooleanOptional=None, EngineVersion: str=None, AllowMajorVersionUpgrade: Boolean=None, AutoMinorVersionUpgrade: BooleanOptional=None, ReplicationInstanceIdentifier: str=None) -> ModifyReplicationInstanceResponse:
        pass

    def modify_replication_subnet_group(self, SubnetIds: List[String], ReplicationSubnetGroupIdentifier: str, ReplicationSubnetGroupDescription: str=None) -> ModifyReplicationSubnetGroupResponse:
        pass

    def modify_replication_task(self, ReplicationTaskArn: str, ReplicationTaskIdentifier: str=None, MigrationType: str=None, TableMappings: str=None, ReplicationTaskSettings: str=None, CdcStartTime: TStamp=None, CdcStartPosition: str=None, CdcStopPosition: str=None) -> ModifyReplicationTaskResponse:
        pass

    def reboot_replication_instance(self, ReplicationInstanceArn: str, ForceFailover: BooleanOptional=None) -> RebootReplicationInstanceResponse:
        pass

    def refresh_schemas(self, ReplicationInstanceArn: str, EndpointArn: str) -> RefreshSchemasResponse:
        pass

    def reload_tables(self, TablesToReload: List[TableToReload], ReplicationTaskArn: str, ReloadOption: str=None) -> ReloadTablesResponse:
        pass

    def remove_tags_from_resource(self, TagKeys: List[String], ResourceArn: str) -> RemoveTagsFromResourceResponse:
        pass

    def start_replication_task(self, StartReplicationTaskType: str, ReplicationTaskArn: str, CdcStartTime: TStamp=None, CdcStartPosition: str=None, CdcStopPosition: str=None) -> StartReplicationTaskResponse:
        pass

    def start_replication_task_assessment(self, ReplicationTaskArn: str) -> StartReplicationTaskAssessmentResponse:
        pass

    def stop_replication_task(self, ReplicationTaskArn: str) -> StopReplicationTaskResponse:
        pass

    def test_connection(self, EndpointArn: str, ReplicationInstanceArn: str) -> TestConnectionResponse:
        pass


class DocDB(BaseClient):
    class AddTagsToResourceMessage(Mapping):
        pass

    class Tag(Mapping):
        pass

    class ApplyPendingMaintenanceActionMessage(Mapping):
        pass

    class ApplyPendingMaintenanceActionResult(Mapping):
        pass

    class CopyDBClusterParameterGroupMessage(Mapping):
        pass

    class CopyDBClusterParameterGroupResult(Mapping):
        pass

    class CopyDBClusterSnapshotMessage(Mapping):
        pass

    class CopyDBClusterSnapshotResult(Mapping):
        pass

    class BooleanOptional(object):
        pass

    class CreateDBClusterMessage(Mapping):
        pass

    class CreateDBClusterResult(Mapping):
        pass

    class String(object):
        pass

    class CreateDBClusterParameterGroupMessage(Mapping):
        pass

    class CreateDBClusterParameterGroupResult(Mapping):
        pass

    class CreateDBClusterSnapshotMessage(Mapping):
        pass

    class CreateDBClusterSnapshotResult(Mapping):
        pass

    class CreateDBInstanceMessage(Mapping):
        pass

    class CreateDBInstanceResult(Mapping):
        pass

    class CreateDBSubnetGroupMessage(Mapping):
        pass

    class CreateDBSubnetGroupResult(Mapping):
        pass

    class DeleteDBClusterMessage(Mapping):
        pass

    class DeleteDBClusterResult(Mapping):
        pass

    class Boolean(object):
        pass

    class DeleteDBClusterParameterGroupMessage(Mapping):
        pass

    class DeleteDBClusterSnapshotMessage(Mapping):
        pass

    class DeleteDBClusterSnapshotResult(Mapping):
        pass

    class DeleteDBInstanceMessage(Mapping):
        pass

    class DeleteDBInstanceResult(Mapping):
        pass

    class DeleteDBSubnetGroupMessage(Mapping):
        pass

    class DescribeDBClusterParameterGroupsMessage(Mapping):
        pass

    class DBClusterParameterGroupsMessage(Mapping):
        pass

    class Filter(Mapping):
        pass

    class DescribeDBClusterParametersMessage(Mapping):
        pass

    class DBClusterParameterGroupDetails(Mapping):
        pass

    class DescribeDBClusterSnapshotAttributesMessage(Mapping):
        pass

    class DescribeDBClusterSnapshotAttributesResult(Mapping):
        pass

    class DescribeDBClusterSnapshotsMessage(Mapping):
        pass

    class DBClusterSnapshotMessage(Mapping):
        pass

    class DescribeDBClustersMessage(Mapping):
        pass

    class DBClusterMessage(Mapping):
        pass

    class DescribeDBEngineVersionsMessage(Mapping):
        pass

    class DBEngineVersionMessage(Mapping):
        pass

    class DescribeDBInstancesMessage(Mapping):
        pass

    class DBInstanceMessage(Mapping):
        pass

    class DescribeDBSubnetGroupsMessage(Mapping):
        pass

    class DBSubnetGroupMessage(Mapping):
        pass

    class DescribeEngineDefaultClusterParametersMessage(Mapping):
        pass

    class DescribeEngineDefaultClusterParametersResult(Mapping):
        pass

    class DescribeEventCategoriesMessage(Mapping):
        pass

    class EventCategoriesMessage(Mapping):
        pass

    class DescribeEventsMessage(Mapping):
        pass

    class EventsMessage(Mapping):
        pass

    class TStamp(object):
        pass

    class DescribeOrderableDBInstanceOptionsMessage(Mapping):
        pass

    class OrderableDBInstanceOptionsMessage(Mapping):
        pass

    class DescribePendingMaintenanceActionsMessage(Mapping):
        pass

    class PendingMaintenanceActionsMessage(Mapping):
        pass

    class FailoverDBClusterMessage(Mapping):
        pass

    class FailoverDBClusterResult(Mapping):
        pass

    class ListTagsForResourceMessage(Mapping):
        pass

    class TagListMessage(Mapping):
        pass

    class ModifyDBClusterMessage(Mapping):
        pass

    class ModifyDBClusterResult(Mapping):
        pass

    class CloudwatchLogsExportConfiguration(Mapping):
        pass

    class ModifyDBClusterParameterGroupMessage(Mapping):
        pass

    class DBClusterParameterGroupNameMessage(Mapping):
        pass

    class Parameter(Mapping):
        pass

    class ModifyDBClusterSnapshotAttributeMessage(Mapping):
        pass

    class ModifyDBClusterSnapshotAttributeResult(Mapping):
        pass

    class ModifyDBInstanceMessage(Mapping):
        pass

    class ModifyDBInstanceResult(Mapping):
        pass

    class ModifyDBSubnetGroupMessage(Mapping):
        pass

    class ModifyDBSubnetGroupResult(Mapping):
        pass

    class RebootDBInstanceMessage(Mapping):
        pass

    class RebootDBInstanceResult(Mapping):
        pass

    class RemoveTagsFromResourceMessage(Mapping):
        pass

    class ResetDBClusterParameterGroupMessage(Mapping):
        pass

    class RestoreDBClusterFromSnapshotMessage(Mapping):
        pass

    class RestoreDBClusterFromSnapshotResult(Mapping):
        pass

    class RestoreDBClusterToPointInTimeMessage(Mapping):
        pass

    class RestoreDBClusterToPointInTimeResult(Mapping):
        pass

    def add_tags_to_resource(self, Tags: List[Tag], ResourceName: str):
        pass

    def apply_pending_maintenance_action(self, OptInType: str, ApplyAction: str, ResourceIdentifier: str) -> ApplyPendingMaintenanceActionResult:
        pass

    def copy_db_cluster_parameter_group(self, TargetDBClusterParameterGroupDescription: str, TargetDBClusterParameterGroupIdentifier: str, SourceDBClusterParameterGroupIdentifier: str, Tags: List[Tag]=None) -> CopyDBClusterParameterGroupResult:
        pass

    def copy_db_cluster_snapshot(self, TargetDBClusterSnapshotIdentifier: str, SourceDBClusterSnapshotIdentifier: str, KmsKeyId: str=None, PreSignedUrl: str=None, CopyTags: BooleanOptional=None, Tags: List[Tag]=None) -> CopyDBClusterSnapshotResult:
        pass

    def create_db_cluster(self, Engine: str, DBClusterIdentifier: str, AvailabilityZones: List[String]=None, BackupRetentionPeriod: int=None, DBClusterParameterGroupName: str=None, VpcSecurityGroupIds: List[String]=None, DBSubnetGroupName: str=None, EngineVersion: str=None, Port: int=None, MasterUsername: str=None, MasterUserPassword: str=None, PreferredBackupWindow: str=None, PreferredMaintenanceWindow: str=None, Tags: List[Tag]=None, StorageEncrypted: BooleanOptional=None, KmsKeyId: str=None, EnableCloudwatchLogsExports: List[String]=None) -> CreateDBClusterResult:
        pass

    def create_db_cluster_parameter_group(self, Description: str, DBParameterGroupFamily: str, DBClusterParameterGroupName: str, Tags: List[Tag]=None) -> CreateDBClusterParameterGroupResult:
        pass

    def create_db_cluster_snapshot(self, DBClusterIdentifier: str, DBClusterSnapshotIdentifier: str, Tags: List[Tag]=None) -> CreateDBClusterSnapshotResult:
        pass

    def create_db_instance(self, DBClusterIdentifier: str, Engine: str, DBInstanceClass: str, DBInstanceIdentifier: str, AvailabilityZone: str=None, PreferredMaintenanceWindow: str=None, AutoMinorVersionUpgrade: BooleanOptional=None, Tags: List[Tag]=None, PromotionTier: int=None) -> CreateDBInstanceResult:
        pass

    def create_db_subnet_group(self, SubnetIds: List[String], DBSubnetGroupDescription: str, DBSubnetGroupName: str, Tags: List[Tag]=None) -> CreateDBSubnetGroupResult:
        pass

    def delete_db_cluster(self, DBClusterIdentifier: str, SkipFinalSnapshot: Boolean=None, FinalDBSnapshotIdentifier: str=None) -> DeleteDBClusterResult:
        pass

    def delete_db_cluster_parameter_group(self, DBClusterParameterGroupName: str):
        pass

    def delete_db_cluster_snapshot(self, DBClusterSnapshotIdentifier: str) -> DeleteDBClusterSnapshotResult:
        pass

    def delete_db_instance(self, DBInstanceIdentifier: str) -> DeleteDBInstanceResult:
        pass

    def delete_db_subnet_group(self, DBSubnetGroupName: str):
        pass

    def describe_db_cluster_parameter_groups(self, DBClusterParameterGroupName: str=None, Filters: List[Filter]=None, MaxRecords: int=None, Marker: str=None) -> DBClusterParameterGroupsMessage:
        pass

    def describe_db_cluster_parameters(self, DBClusterParameterGroupName: str, Source: str=None, Filters: List[Filter]=None, MaxRecords: int=None, Marker: str=None) -> DBClusterParameterGroupDetails:
        pass

    def describe_db_cluster_snapshot_attributes(self, DBClusterSnapshotIdentifier: str) -> DescribeDBClusterSnapshotAttributesResult:
        pass

    def describe_db_cluster_snapshots(self, DBClusterIdentifier: str=None, DBClusterSnapshotIdentifier: str=None, SnapshotType: str=None, Filters: List[Filter]=None, MaxRecords: int=None, Marker: str=None, IncludeShared: Boolean=None, IncludePublic: Boolean=None) -> DBClusterSnapshotMessage:
        pass

    def describe_db_clusters(self, DBClusterIdentifier: str=None, Filters: List[Filter]=None, MaxRecords: int=None, Marker: str=None) -> DBClusterMessage:
        pass

    def describe_db_engine_versions(self, Engine: str=None, EngineVersion: str=None, DBParameterGroupFamily: str=None, Filters: List[Filter]=None, MaxRecords: int=None, Marker: str=None, DefaultOnly: Boolean=None, ListSupportedCharacterSets: BooleanOptional=None, ListSupportedTimezones: BooleanOptional=None) -> DBEngineVersionMessage:
        pass

    def describe_db_instances(self, DBInstanceIdentifier: str=None, Filters: List[Filter]=None, MaxRecords: int=None, Marker: str=None) -> DBInstanceMessage:
        pass

    def describe_db_subnet_groups(self, DBSubnetGroupName: str=None, Filters: List[Filter]=None, MaxRecords: int=None, Marker: str=None) -> DBSubnetGroupMessage:
        pass

    def describe_engine_default_cluster_parameters(self, DBParameterGroupFamily: str, Filters: List[Filter]=None, MaxRecords: int=None, Marker: str=None) -> DescribeEngineDefaultClusterParametersResult:
        pass

    def describe_event_categories(self, SourceType: str=None, Filters: List[Filter]=None) -> EventCategoriesMessage:
        pass

    def describe_events(self, SourceIdentifier: str=None, SourceType: str=None, StartTime: TStamp=None, EndTime: TStamp=None, Duration: int=None, EventCategories: List[String]=None, Filters: List[Filter]=None, MaxRecords: int=None, Marker: str=None) -> EventsMessage:
        pass

    def describe_orderable_db_instance_options(self, Engine: str, EngineVersion: str=None, DBInstanceClass: str=None, LicenseModel: str=None, Vpc: BooleanOptional=None, Filters: List[Filter]=None, MaxRecords: int=None, Marker: str=None) -> OrderableDBInstanceOptionsMessage:
        pass

    def describe_pending_maintenance_actions(self, ResourceIdentifier: str=None, Filters: List[Filter]=None, Marker: str=None, MaxRecords: int=None) -> PendingMaintenanceActionsMessage:
        pass

    def failover_db_cluster(self, DBClusterIdentifier: str=None, TargetDBInstanceIdentifier: str=None) -> FailoverDBClusterResult:
        pass

    def list_tags_for_resource(self, ResourceName: str, Filters: List[Filter]=None) -> TagListMessage:
        pass

    def modify_db_cluster(self, DBClusterIdentifier: str, NewDBClusterIdentifier: str=None, ApplyImmediately: Boolean=None, BackupRetentionPeriod: int=None, DBClusterParameterGroupName: str=None, VpcSecurityGroupIds: List[String]=None, Port: int=None, MasterUserPassword: str=None, PreferredBackupWindow: str=None, PreferredMaintenanceWindow: str=None, CloudwatchLogsExportConfiguration: CloudwatchLogsExportConfiguration=None, EngineVersion: str=None) -> ModifyDBClusterResult:
        pass

    def modify_db_cluster_parameter_group(self, Parameters: List[Parameter], DBClusterParameterGroupName: str) -> DBClusterParameterGroupNameMessage:
        pass

    def modify_db_cluster_snapshot_attribute(self, AttributeName: str, DBClusterSnapshotIdentifier: str, ValuesToAdd: List[String]=None, ValuesToRemove: List[String]=None) -> ModifyDBClusterSnapshotAttributeResult:
        pass

    def modify_db_instance(self, DBInstanceIdentifier: str, DBInstanceClass: str=None, ApplyImmediately: Boolean=None, PreferredMaintenanceWindow: str=None, AutoMinorVersionUpgrade: BooleanOptional=None, NewDBInstanceIdentifier: str=None, PromotionTier: int=None) -> ModifyDBInstanceResult:
        pass

    def modify_db_subnet_group(self, SubnetIds: List[String], DBSubnetGroupName: str, DBSubnetGroupDescription: str=None) -> ModifyDBSubnetGroupResult:
        pass

    def reboot_db_instance(self, DBInstanceIdentifier: str, ForceFailover: BooleanOptional=None) -> RebootDBInstanceResult:
        pass

    def remove_tags_from_resource(self, TagKeys: List[String], ResourceName: str):
        pass

    def reset_db_cluster_parameter_group(self, DBClusterParameterGroupName: str, ResetAllParameters: Boolean=None, Parameters: List[Parameter]=None) -> DBClusterParameterGroupNameMessage:
        pass

    def restore_db_cluster_from_snapshot(self, Engine: str, SnapshotIdentifier: str, DBClusterIdentifier: str, AvailabilityZones: List[String]=None, EngineVersion: str=None, Port: int=None, DBSubnetGroupName: str=None, VpcSecurityGroupIds: List[String]=None, Tags: List[Tag]=None, KmsKeyId: str=None, EnableCloudwatchLogsExports: List[String]=None) -> RestoreDBClusterFromSnapshotResult:
        pass

    def restore_db_cluster_to_point_in_time(self, SourceDBClusterIdentifier: str, DBClusterIdentifier: str, RestoreToTime: TStamp=None, UseLatestRestorableTime: Boolean=None, Port: int=None, DBSubnetGroupName: str=None, VpcSecurityGroupIds: List[String]=None, Tags: List[Tag]=None, KmsKeyId: str=None, EnableCloudwatchLogsExports: List[String]=None) -> RestoreDBClusterToPointInTimeResult:
        pass


class DirectoryService(BaseClient):
    class AcceptSharedDirectoryRequest(Mapping):
        pass

    class AcceptSharedDirectoryResult(Mapping):
        pass

    class AddIpRoutesRequest(Mapping):
        pass

    class AddIpRoutesResult(Mapping):
        pass

    class IpRoute(Mapping):
        pass

    class UpdateSecurityGroupForDirectoryControllers(object):
        pass

    class AddTagsToResourceRequest(Mapping):
        pass

    class AddTagsToResourceResult(Mapping):
        pass

    class Tag(Mapping):
        pass

    class CancelSchemaExtensionRequest(Mapping):
        pass

    class CancelSchemaExtensionResult(Mapping):
        pass

    class ConnectDirectoryRequest(Mapping):
        pass

    class ConnectDirectoryResult(Mapping):
        pass

    class DirectoryConnectSettings(Mapping):
        pass

    class CreateAliasRequest(Mapping):
        pass

    class CreateAliasResult(Mapping):
        pass

    class CreateComputerRequest(Mapping):
        pass

    class CreateComputerResult(Mapping):
        pass

    class Attribute(Mapping):
        pass

    class CreateConditionalForwarderRequest(Mapping):
        pass

    class CreateConditionalForwarderResult(Mapping):
        pass

    class IpAddr(object):
        pass

    class CreateDirectoryRequest(Mapping):
        pass

    class CreateDirectoryResult(Mapping):
        pass

    class DirectoryVpcSettings(Mapping):
        pass

    class CreateLogSubscriptionRequest(Mapping):
        pass

    class CreateLogSubscriptionResult(Mapping):
        pass

    class CreateMicrosoftADRequest(Mapping):
        pass

    class CreateMicrosoftADResult(Mapping):
        pass

    class CreateSnapshotRequest(Mapping):
        pass

    class CreateSnapshotResult(Mapping):
        pass

    class CreateTrustRequest(Mapping):
        pass

    class CreateTrustResult(Mapping):
        pass

    class DeleteConditionalForwarderRequest(Mapping):
        pass

    class DeleteConditionalForwarderResult(Mapping):
        pass

    class DeleteDirectoryRequest(Mapping):
        pass

    class DeleteDirectoryResult(Mapping):
        pass

    class DeleteLogSubscriptionRequest(Mapping):
        pass

    class DeleteLogSubscriptionResult(Mapping):
        pass

    class DeleteSnapshotRequest(Mapping):
        pass

    class DeleteSnapshotResult(Mapping):
        pass

    class DeleteTrustRequest(Mapping):
        pass

    class DeleteTrustResult(Mapping):
        pass

    class DeleteAssociatedConditionalForwarder(object):
        pass

    class DeregisterEventTopicRequest(Mapping):
        pass

    class DeregisterEventTopicResult(Mapping):
        pass

    class DescribeConditionalForwardersRequest(Mapping):
        pass

    class DescribeConditionalForwardersResult(Mapping):
        pass

    class RemoteDomainName(object):
        pass

    class DescribeDirectoriesRequest(Mapping):
        pass

    class DescribeDirectoriesResult(Mapping):
        pass

    class DirectoryId(object):
        pass

    class DescribeDomainControllersRequest(Mapping):
        pass

    class DescribeDomainControllersResult(Mapping):
        pass

    class DomainControllerId(object):
        pass

    class DescribeEventTopicsRequest(Mapping):
        pass

    class DescribeEventTopicsResult(Mapping):
        pass

    class TopicName(object):
        pass

    class DescribeSharedDirectoriesRequest(Mapping):
        pass

    class DescribeSharedDirectoriesResult(Mapping):
        pass

    class DescribeSnapshotsRequest(Mapping):
        pass

    class DescribeSnapshotsResult(Mapping):
        pass

    class SnapshotId(object):
        pass

    class DescribeTrustsRequest(Mapping):
        pass

    class DescribeTrustsResult(Mapping):
        pass

    class TrustId(object):
        pass

    class DisableRadiusRequest(Mapping):
        pass

    class DisableRadiusResult(Mapping):
        pass

    class DisableSsoRequest(Mapping):
        pass

    class DisableSsoResult(Mapping):
        pass

    class EnableRadiusRequest(Mapping):
        pass

    class EnableRadiusResult(Mapping):
        pass

    class RadiusSettings(Mapping):
        pass

    class EnableSsoRequest(Mapping):
        pass

    class EnableSsoResult(Mapping):
        pass

    class GetDirectoryLimitsRequest(Mapping):
        pass

    class GetDirectoryLimitsResult(Mapping):
        pass

    class GetSnapshotLimitsRequest(Mapping):
        pass

    class GetSnapshotLimitsResult(Mapping):
        pass

    class ListIpRoutesRequest(Mapping):
        pass

    class ListIpRoutesResult(Mapping):
        pass

    class ListLogSubscriptionsRequest(Mapping):
        pass

    class ListLogSubscriptionsResult(Mapping):
        pass

    class ListSchemaExtensionsRequest(Mapping):
        pass

    class ListSchemaExtensionsResult(Mapping):
        pass

    class ListTagsForResourceRequest(Mapping):
        pass

    class ListTagsForResourceResult(Mapping):
        pass

    class RegisterEventTopicRequest(Mapping):
        pass

    class RegisterEventTopicResult(Mapping):
        pass

    class RejectSharedDirectoryRequest(Mapping):
        pass

    class RejectSharedDirectoryResult(Mapping):
        pass

    class RemoveIpRoutesRequest(Mapping):
        pass

    class RemoveIpRoutesResult(Mapping):
        pass

    class CidrIp(object):
        pass

    class RemoveTagsFromResourceRequest(Mapping):
        pass

    class RemoveTagsFromResourceResult(Mapping):
        pass

    class TagKey(object):
        pass

    class ResetUserPasswordRequest(Mapping):
        pass

    class ResetUserPasswordResult(Mapping):
        pass

    class RestoreFromSnapshotRequest(Mapping):
        pass

    class RestoreFromSnapshotResult(Mapping):
        pass

    class ShareDirectoryRequest(Mapping):
        pass

    class ShareDirectoryResult(Mapping):
        pass

    class ShareTarget(Mapping):
        pass

    class StartSchemaExtensionRequest(Mapping):
        pass

    class StartSchemaExtensionResult(Mapping):
        pass

    class CreateSnapshotBeforeSchemaExtension(object):
        pass

    class UnshareDirectoryRequest(Mapping):
        pass

    class UnshareDirectoryResult(Mapping):
        pass

    class UnshareTarget(Mapping):
        pass

    class UpdateConditionalForwarderRequest(Mapping):
        pass

    class UpdateConditionalForwarderResult(Mapping):
        pass

    class UpdateNumberOfDomainControllersRequest(Mapping):
        pass

    class UpdateNumberOfDomainControllersResult(Mapping):
        pass

    class UpdateRadiusRequest(Mapping):
        pass

    class UpdateRadiusResult(Mapping):
        pass

    class UpdateTrustRequest(Mapping):
        pass

    class UpdateTrustResult(Mapping):
        pass

    class VerifyTrustRequest(Mapping):
        pass

    class VerifyTrustResult(Mapping):
        pass

    def accept_shared_directory(self, SharedDirectoryId: str) -> AcceptSharedDirectoryResult:
        pass

    def add_ip_routes(self, IpRoutes: List[IpRoute], DirectoryId: str, UpdateSecurityGroupForDirectoryControllers: UpdateSecurityGroupForDirectoryControllers=None) -> AddIpRoutesResult:
        pass

    def add_tags_to_resource(self, Tags: List[Tag], ResourceId: str) -> AddTagsToResourceResult:
        pass

    def cancel_schema_extension(self, SchemaExtensionId: str, DirectoryId: str) -> CancelSchemaExtensionResult:
        pass

    def connect_directory(self, ConnectSettings: DirectoryConnectSettings, Size: str, Password: str, Name: str, ShortName: str=None, Description: str=None) -> ConnectDirectoryResult:
        pass

    def create_alias(self, Alias: str, DirectoryId: str) -> CreateAliasResult:
        pass

    def create_computer(self, Password: str, ComputerName: str, DirectoryId: str, OrganizationalUnitDistinguishedName: str=None, ComputerAttributes: List[Attribute]=None) -> CreateComputerResult:
        pass

    def create_conditional_forwarder(self, DnsIpAddrs: List[IpAddr], RemoteDomainName: str, DirectoryId: str) -> CreateConditionalForwarderResult:
        pass

    def create_directory(self, Size: str, Password: str, Name: str, ShortName: str=None, Description: str=None, VpcSettings: DirectoryVpcSettings=None) -> CreateDirectoryResult:
        pass

    def create_log_subscription(self, LogGroupName: str, DirectoryId: str) -> CreateLogSubscriptionResult:
        pass

    def create_microsoft_ad(self, VpcSettings: DirectoryVpcSettings, Password: str, Name: str, ShortName: str=None, Description: str=None, Edition: str=None) -> CreateMicrosoftADResult:
        pass

    def create_snapshot(self, DirectoryId: str, Name: str=None) -> CreateSnapshotResult:
        pass

    def create_trust(self, TrustDirection: str, TrustPassword: str, RemoteDomainName: str, DirectoryId: str, TrustType: str=None, ConditionalForwarderIpAddrs: List[IpAddr]=None, SelectiveAuth: str=None) -> CreateTrustResult:
        pass

    def delete_conditional_forwarder(self, RemoteDomainName: str, DirectoryId: str) -> DeleteConditionalForwarderResult:
        pass

    def delete_directory(self, DirectoryId: str) -> DeleteDirectoryResult:
        pass

    def delete_log_subscription(self, DirectoryId: str) -> DeleteLogSubscriptionResult:
        pass

    def delete_snapshot(self, SnapshotId: str) -> DeleteSnapshotResult:
        pass

    def delete_trust(self, TrustId: str, DeleteAssociatedConditionalForwarder: DeleteAssociatedConditionalForwarder=None) -> DeleteTrustResult:
        pass

    def deregister_event_topic(self, TopicName: str, DirectoryId: str) -> DeregisterEventTopicResult:
        pass

    def describe_conditional_forwarders(self, DirectoryId: str, RemoteDomainNames: List[RemoteDomainName]=None) -> DescribeConditionalForwardersResult:
        pass

    def describe_directories(self, DirectoryIds: List[DirectoryId]=None, NextToken: str=None, Limit: int=None) -> DescribeDirectoriesResult:
        pass

    def describe_domain_controllers(self, DirectoryId: str, DomainControllerIds: List[DomainControllerId]=None, NextToken: str=None, Limit: int=None) -> DescribeDomainControllersResult:
        pass

    def describe_event_topics(self, DirectoryId: str=None, TopicNames: List[TopicName]=None) -> DescribeEventTopicsResult:
        pass

    def describe_shared_directories(self, OwnerDirectoryId: str, SharedDirectoryIds: List[DirectoryId]=None, NextToken: str=None, Limit: int=None) -> DescribeSharedDirectoriesResult:
        pass

    def describe_snapshots(self, DirectoryId: str=None, SnapshotIds: List[SnapshotId]=None, NextToken: str=None, Limit: int=None) -> DescribeSnapshotsResult:
        pass

    def describe_trusts(self, DirectoryId: str=None, TrustIds: List[TrustId]=None, NextToken: str=None, Limit: int=None) -> DescribeTrustsResult:
        pass

    def disable_radius(self, DirectoryId: str) -> DisableRadiusResult:
        pass

    def disable_sso(self, DirectoryId: str, UserName: str=None, Password: str=None) -> DisableSsoResult:
        pass

    def enable_radius(self, RadiusSettings: RadiusSettings, DirectoryId: str) -> EnableRadiusResult:
        pass

    def enable_sso(self, DirectoryId: str, UserName: str=None, Password: str=None) -> EnableSsoResult:
        pass

    def get_directory_limits(self) -> GetDirectoryLimitsResult:
        pass

    def get_snapshot_limits(self, DirectoryId: str) -> GetSnapshotLimitsResult:
        pass

    def list_ip_routes(self, DirectoryId: str, NextToken: str=None, Limit: int=None) -> ListIpRoutesResult:
        pass

    def list_log_subscriptions(self, DirectoryId: str=None, NextToken: str=None, Limit: int=None) -> ListLogSubscriptionsResult:
        pass

    def list_schema_extensions(self, DirectoryId: str, NextToken: str=None, Limit: int=None) -> ListSchemaExtensionsResult:
        pass

    def list_tags_for_resource(self, ResourceId: str, NextToken: str=None, Limit: int=None) -> ListTagsForResourceResult:
        pass

    def register_event_topic(self, TopicName: str, DirectoryId: str) -> RegisterEventTopicResult:
        pass

    def reject_shared_directory(self, SharedDirectoryId: str) -> RejectSharedDirectoryResult:
        pass

    def remove_ip_routes(self, CidrIps: List[CidrIp], DirectoryId: str) -> RemoveIpRoutesResult:
        pass

    def remove_tags_from_resource(self, TagKeys: List[TagKey], ResourceId: str) -> RemoveTagsFromResourceResult:
        pass

    def reset_user_password(self, NewPassword: str, UserName: str, DirectoryId: str) -> ResetUserPasswordResult:
        pass

    def restore_from_snapshot(self, SnapshotId: str) -> RestoreFromSnapshotResult:
        pass

    def share_directory(self, ShareMethod: str, ShareTarget: ShareTarget, DirectoryId: str, ShareNotes: str=None) -> ShareDirectoryResult:
        pass

    def start_schema_extension(self, Description: str, LdifContent: str, CreateSnapshotBeforeSchemaExtension: CreateSnapshotBeforeSchemaExtension, DirectoryId: str) -> StartSchemaExtensionResult:
        pass

    def unshare_directory(self, UnshareTarget: UnshareTarget, DirectoryId: str) -> UnshareDirectoryResult:
        pass

    def update_conditional_forwarder(self, DnsIpAddrs: List[IpAddr], RemoteDomainName: str, DirectoryId: str) -> UpdateConditionalForwarderResult:
        pass

    def update_number_of_domain_controllers(self, DesiredNumber: int, DirectoryId: str) -> UpdateNumberOfDomainControllersResult:
        pass

    def update_radius(self, RadiusSettings: RadiusSettings, DirectoryId: str) -> UpdateRadiusResult:
        pass

    def update_trust(self, TrustId: str, SelectiveAuth: str=None) -> UpdateTrustResult:
        pass

    def verify_trust(self, TrustId: str) -> VerifyTrustResult:
        pass


class DynamoDB(BaseClient):
    class BatchGetItemInput(Mapping):
        pass

    class BatchGetItemOutput(Mapping):
        pass

    class BatchGetRequestMap(object):
        pass

    class BatchWriteItemInput(Mapping):
        pass

    class BatchWriteItemOutput(Mapping):
        pass

    class BatchWriteItemRequestMap(object):
        pass

    class CreateBackupInput(Mapping):
        pass

    class CreateBackupOutput(Mapping):
        pass

    class CreateGlobalTableInput(Mapping):
        pass

    class CreateGlobalTableOutput(Mapping):
        pass

    class Replica(Mapping):
        pass

    class CreateTableInput(Mapping):
        pass

    class CreateTableOutput(Mapping):
        pass

    class AttributeDefinition(Mapping):
        pass

    class KeySchemaElement(Mapping):
        pass

    class LocalSecondaryIndex(Mapping):
        pass

    class GlobalSecondaryIndex(Mapping):
        pass

    class ProvisionedThroughput(Mapping):
        pass

    class StreamSpecification(Mapping):
        pass

    class SSESpecification(Mapping):
        pass

    class DeleteBackupInput(Mapping):
        pass

    class DeleteBackupOutput(Mapping):
        pass

    class DeleteItemInput(Mapping):
        pass

    class DeleteItemOutput(Mapping):
        pass

    class Key(object):
        pass

    class ExpectedAttributeMap(object):
        pass

    class ExpressionAttributeNameMap(object):
        pass

    class ExpressionAttributeValueMap(object):
        pass

    class DeleteTableInput(Mapping):
        pass

    class DeleteTableOutput(Mapping):
        pass

    class DescribeBackupInput(Mapping):
        pass

    class DescribeBackupOutput(Mapping):
        pass

    class DescribeContinuousBackupsInput(Mapping):
        pass

    class DescribeContinuousBackupsOutput(Mapping):
        pass

    class DescribeEndpointsRequest(Mapping):
        pass

    class DescribeEndpointsResponse(Mapping):
        pass

    class DescribeGlobalTableInput(Mapping):
        pass

    class DescribeGlobalTableOutput(Mapping):
        pass

    class DescribeGlobalTableSettingsInput(Mapping):
        pass

    class DescribeGlobalTableSettingsOutput(Mapping):
        pass

    class DescribeLimitsInput(Mapping):
        pass

    class DescribeLimitsOutput(Mapping):
        pass

    class DescribeTableInput(Mapping):
        pass

    class DescribeTableOutput(Mapping):
        pass

    class DescribeTimeToLiveInput(Mapping):
        pass

    class DescribeTimeToLiveOutput(Mapping):
        pass

    class GetItemInput(Mapping):
        pass

    class GetItemOutput(Mapping):
        pass

    class AttributeName(object):
        pass

    class ConsistentRead(object):
        pass

    class ListBackupsInput(Mapping):
        pass

    class ListBackupsOutput(Mapping):
        pass

    class TimeRangeLowerBound(object):
        pass

    class TimeRangeUpperBound(object):
        pass

    class ListGlobalTablesInput(Mapping):
        pass

    class ListGlobalTablesOutput(Mapping):
        pass

    class ListTablesInput(Mapping):
        pass

    class ListTablesOutput(Mapping):
        pass

    class ListTagsOfResourceInput(Mapping):
        pass

    class ListTagsOfResourceOutput(Mapping):
        pass

    class PutItemInput(Mapping):
        pass

    class PutItemOutput(Mapping):
        pass

    class PutItemInputAttributeMap(object):
        pass

    class QueryInput(Mapping):
        pass

    class QueryOutput(Mapping):
        pass

    class KeyConditions(object):
        pass

    class FilterConditionMap(object):
        pass

    class BooleanObject(object):
        pass

    class RestoreTableFromBackupInput(Mapping):
        pass

    class RestoreTableFromBackupOutput(Mapping):
        pass

    class RestoreTableToPointInTimeInput(Mapping):
        pass

    class RestoreTableToPointInTimeOutput(Mapping):
        pass

    class Date(object):
        pass

    class ScanInput(Mapping):
        pass

    class ScanOutput(Mapping):
        pass

    class TagResourceInput(Mapping):
        pass

    class Tag(Mapping):
        pass

    class TransactGetItemsInput(Mapping):
        pass

    class TransactGetItemsOutput(Mapping):
        pass

    class TransactGetItem(Mapping):
        pass

    class TransactWriteItemsInput(Mapping):
        pass

    class TransactWriteItemsOutput(Mapping):
        pass

    class TransactWriteItem(Mapping):
        pass

    class UntagResourceInput(Mapping):
        pass

    class TagKeyString(object):
        pass

    class UpdateContinuousBackupsInput(Mapping):
        pass

    class UpdateContinuousBackupsOutput(Mapping):
        pass

    class PointInTimeRecoverySpecification(Mapping):
        pass

    class UpdateGlobalTableInput(Mapping):
        pass

    class UpdateGlobalTableOutput(Mapping):
        pass

    class ReplicaUpdate(Mapping):
        pass

    class UpdateGlobalTableSettingsInput(Mapping):
        pass

    class UpdateGlobalTableSettingsOutput(Mapping):
        pass

    class PositiveLongObject(object):
        pass

    class AutoScalingSettingsUpdate(Mapping):
        pass

    class GlobalTableGlobalSecondaryIndexSettingsUpdate(Mapping):
        pass

    class ReplicaSettingsUpdate(Mapping):
        pass

    class UpdateItemInput(Mapping):
        pass

    class UpdateItemOutput(Mapping):
        pass

    class AttributeUpdates(object):
        pass

    class UpdateTableInput(Mapping):
        pass

    class UpdateTableOutput(Mapping):
        pass

    class GlobalSecondaryIndexUpdate(Mapping):
        pass

    class UpdateTimeToLiveInput(Mapping):
        pass

    class UpdateTimeToLiveOutput(Mapping):
        pass

    class TimeToLiveSpecification(Mapping):
        pass

    def batch_get_item(self, RequestItems: BatchGetRequestMap, ReturnConsumedCapacity: str=None) -> BatchGetItemOutput:
        pass

    def batch_write_item(self, RequestItems: BatchWriteItemRequestMap, ReturnConsumedCapacity: str=None, ReturnItemCollectionMetrics: str=None) -> BatchWriteItemOutput:
        pass

    def create_backup(self, BackupName: str, TableName: str) -> CreateBackupOutput:
        pass

    def create_global_table(self, ReplicationGroup: List[Replica], GlobalTableName: str) -> CreateGlobalTableOutput:
        pass

    def create_table(self, KeySchema: List[KeySchemaElement], TableName: str, AttributeDefinitions: List[AttributeDefinition], LocalSecondaryIndexes: List[LocalSecondaryIndex]=None, GlobalSecondaryIndexes: List[GlobalSecondaryIndex]=None, BillingMode: str=None, ProvisionedThroughput: ProvisionedThroughput=None, StreamSpecification: StreamSpecification=None, SSESpecification: SSESpecification=None) -> CreateTableOutput:
        pass

    def delete_backup(self, BackupArn: str) -> DeleteBackupOutput:
        pass

    def delete_item(self, Key: Key, TableName: str, Expected: ExpectedAttributeMap=None, ConditionalOperator: str=None, ReturnValues: str=None, ReturnConsumedCapacity: str=None, ReturnItemCollectionMetrics: str=None, ConditionExpression: str=None, ExpressionAttributeNames: ExpressionAttributeNameMap=None, ExpressionAttributeValues: ExpressionAttributeValueMap=None) -> DeleteItemOutput:
        pass

    def delete_table(self, TableName: str) -> DeleteTableOutput:
        pass

    def describe_backup(self, BackupArn: str) -> DescribeBackupOutput:
        pass

    def describe_continuous_backups(self, TableName: str) -> DescribeContinuousBackupsOutput:
        pass

    def describe_endpoints(self) -> DescribeEndpointsResponse:
        pass

    def describe_global_table(self, GlobalTableName: str) -> DescribeGlobalTableOutput:
        pass

    def describe_global_table_settings(self, GlobalTableName: str) -> DescribeGlobalTableSettingsOutput:
        pass

    def describe_limits(self) -> DescribeLimitsOutput:
        pass

    def describe_table(self, TableName: str) -> DescribeTableOutput:
        pass

    def describe_time_to_live(self, TableName: str) -> DescribeTimeToLiveOutput:
        pass

    def get_item(self, Key: Key, TableName: str, AttributesToGet: List[AttributeName]=None, ConsistentRead: ConsistentRead=None, ReturnConsumedCapacity: str=None, ProjectionExpression: str=None, ExpressionAttributeNames: ExpressionAttributeNameMap=None) -> GetItemOutput:
        pass

    def list_backups(self, TableName: str=None, Limit: int=None, TimeRangeLowerBound: TimeRangeLowerBound=None, TimeRangeUpperBound: TimeRangeUpperBound=None, ExclusiveStartBackupArn: str=None, BackupType: str=None) -> ListBackupsOutput:
        pass

    def list_global_tables(self, ExclusiveStartGlobalTableName: str=None, Limit: int=None, RegionName: str=None) -> ListGlobalTablesOutput:
        pass

    def list_tables(self, ExclusiveStartTableName: str=None, Limit: int=None) -> ListTablesOutput:
        pass

    def list_tags_of_resource(self, ResourceArn: str, NextToken: str=None) -> ListTagsOfResourceOutput:
        pass

    def put_item(self, Item: PutItemInputAttributeMap, TableName: str, Expected: ExpectedAttributeMap=None, ReturnValues: str=None, ReturnConsumedCapacity: str=None, ReturnItemCollectionMetrics: str=None, ConditionalOperator: str=None, ConditionExpression: str=None, ExpressionAttributeNames: ExpressionAttributeNameMap=None, ExpressionAttributeValues: ExpressionAttributeValueMap=None) -> PutItemOutput:
        pass

    def query(self, TableName: str, IndexName: str=None, Select: str=None, AttributesToGet: List[AttributeName]=None, Limit: int=None, ConsistentRead: ConsistentRead=None, KeyConditions: KeyConditions=None, QueryFilter: FilterConditionMap=None, ConditionalOperator: str=None, ScanIndexForward: BooleanObject=None, ExclusiveStartKey: Key=None, ReturnConsumedCapacity: str=None, ProjectionExpression: str=None, FilterExpression: str=None, KeyConditionExpression: str=None, ExpressionAttributeNames: ExpressionAttributeNameMap=None, ExpressionAttributeValues: ExpressionAttributeValueMap=None) -> QueryOutput:
        pass

    def restore_table_from_backup(self, BackupArn: str, TargetTableName: str) -> RestoreTableFromBackupOutput:
        pass

    def restore_table_to_point_in_time(self, TargetTableName: str, SourceTableName: str, UseLatestRestorableTime: BooleanObject=None, RestoreDateTime: Date=None) -> RestoreTableToPointInTimeOutput:
        pass

    def scan(self, TableName: str, IndexName: str=None, AttributesToGet: List[AttributeName]=None, Limit: int=None, Select: str=None, ScanFilter: FilterConditionMap=None, ConditionalOperator: str=None, ExclusiveStartKey: Key=None, ReturnConsumedCapacity: str=None, TotalSegments: int=None, Segment: int=None, ProjectionExpression: str=None, FilterExpression: str=None, ExpressionAttributeNames: ExpressionAttributeNameMap=None, ExpressionAttributeValues: ExpressionAttributeValueMap=None, ConsistentRead: ConsistentRead=None) -> ScanOutput:
        pass

    def tag_resource(self, Tags: List[Tag], ResourceArn: str):
        pass

    def transact_get_items(self, TransactItems: List[TransactGetItem], ReturnConsumedCapacity: str=None) -> TransactGetItemsOutput:
        pass

    def transact_write_items(self, TransactItems: List[TransactWriteItem], ReturnConsumedCapacity: str=None, ReturnItemCollectionMetrics: str=None, ClientRequestToken: str=None) -> TransactWriteItemsOutput:
        pass

    def untag_resource(self, TagKeys: List[TagKeyString], ResourceArn: str):
        pass

    def update_continuous_backups(self, PointInTimeRecoverySpecification: PointInTimeRecoverySpecification, TableName: str) -> UpdateContinuousBackupsOutput:
        pass

    def update_global_table(self, ReplicaUpdates: List[ReplicaUpdate], GlobalTableName: str) -> UpdateGlobalTableOutput:
        pass

    def update_global_table_settings(self, GlobalTableName: str, GlobalTableBillingMode: str=None, GlobalTableProvisionedWriteCapacityUnits: PositiveLongObject=None, GlobalTableProvisionedWriteCapacityAutoScalingSettingsUpdate: AutoScalingSettingsUpdate=None, GlobalTableGlobalSecondaryIndexSettingsUpdate: List[GlobalTableGlobalSecondaryIndexSettingsUpdate]=None, ReplicaSettingsUpdate: List[ReplicaSettingsUpdate]=None) -> UpdateGlobalTableSettingsOutput:
        pass

    def update_item(self, Key: Key, TableName: str, AttributeUpdates: AttributeUpdates=None, Expected: ExpectedAttributeMap=None, ConditionalOperator: str=None, ReturnValues: str=None, ReturnConsumedCapacity: str=None, ReturnItemCollectionMetrics: str=None, UpdateExpression: str=None, ConditionExpression: str=None, ExpressionAttributeNames: ExpressionAttributeNameMap=None, ExpressionAttributeValues: ExpressionAttributeValueMap=None) -> UpdateItemOutput:
        pass

    def update_table(self, TableName: str, AttributeDefinitions: List[AttributeDefinition]=None, BillingMode: str=None, ProvisionedThroughput: ProvisionedThroughput=None, GlobalSecondaryIndexUpdates: List[GlobalSecondaryIndexUpdate]=None, StreamSpecification: StreamSpecification=None, SSESpecification: SSESpecification=None) -> UpdateTableOutput:
        pass

    def update_time_to_live(self, TimeToLiveSpecification: TimeToLiveSpecification, TableName: str) -> UpdateTimeToLiveOutput:
        pass


class DynamoDBStreams(BaseClient):
    class DescribeStreamInput(Mapping):
        pass

    class DescribeStreamOutput(Mapping):
        pass

    class GetRecordsInput(Mapping):
        pass

    class GetRecordsOutput(Mapping):
        pass

    class GetShardIteratorInput(Mapping):
        pass

    class GetShardIteratorOutput(Mapping):
        pass

    class ListStreamsInput(Mapping):
        pass

    class ListStreamsOutput(Mapping):
        pass

    def describe_stream(self, StreamArn: str, Limit: int=None, ExclusiveStartShardId: str=None) -> DescribeStreamOutput:
        pass

    def get_records(self, ShardIterator: str, Limit: int=None) -> GetRecordsOutput:
        pass

    def get_shard_iterator(self, ShardIteratorType: str, ShardId: str, StreamArn: str, SequenceNumber: str=None) -> GetShardIteratorOutput:
        pass

    def list_streams(self, TableName: str=None, Limit: int=None, ExclusiveStartStreamArn: str=None) -> ListStreamsOutput:
        pass


class EC2(BaseClient):
    class AcceptReservedInstancesExchangeQuoteRequest(Mapping):
        pass

    class AcceptReservedInstancesExchangeQuoteResult(Mapping):
        pass

    class Boolean(object):
        pass

    class String(object):
        pass

    class TargetConfigurationRequest(Mapping):
        pass

    class AcceptTransitGatewayVpcAttachmentRequest(Mapping):
        pass

    class AcceptTransitGatewayVpcAttachmentResult(Mapping):
        pass

    class AcceptVpcEndpointConnectionsRequest(Mapping):
        pass

    class AcceptVpcEndpointConnectionsResult(Mapping):
        pass

    class AcceptVpcPeeringConnectionRequest(Mapping):
        pass

    class AcceptVpcPeeringConnectionResult(Mapping):
        pass

    class AdvertiseByoipCidrRequest(Mapping):
        pass

    class AdvertiseByoipCidrResult(Mapping):
        pass

    class AllocateAddressRequest(Mapping):
        pass

    class AllocateAddressResult(Mapping):
        pass

    class AllocateHostsRequest(Mapping):
        pass

    class AllocateHostsResult(Mapping):
        pass

    class TagSpecification(Mapping):
        pass

    class ApplySecurityGroupsToClientVpnTargetNetworkRequest(Mapping):
        pass

    class ApplySecurityGroupsToClientVpnTargetNetworkResult(Mapping):
        pass

    class AssignIpv6AddressesRequest(Mapping):
        pass

    class AssignIpv6AddressesResult(Mapping):
        pass

    class AssignPrivateIpAddressesRequest(Mapping):
        pass

    class AssociateAddressRequest(Mapping):
        pass

    class AssociateAddressResult(Mapping):
        pass

    class AssociateClientVpnTargetNetworkRequest(Mapping):
        pass

    class AssociateClientVpnTargetNetworkResult(Mapping):
        pass

    class AssociateDhcpOptionsRequest(Mapping):
        pass

    class AssociateIamInstanceProfileRequest(Mapping):
        pass

    class AssociateIamInstanceProfileResult(Mapping):
        pass

    class IamInstanceProfileSpecification(Mapping):
        pass

    class AssociateRouteTableRequest(Mapping):
        pass

    class AssociateRouteTableResult(Mapping):
        pass

    class AssociateSubnetCidrBlockRequest(Mapping):
        pass

    class AssociateSubnetCidrBlockResult(Mapping):
        pass

    class AssociateTransitGatewayRouteTableRequest(Mapping):
        pass

    class AssociateTransitGatewayRouteTableResult(Mapping):
        pass

    class AssociateVpcCidrBlockRequest(Mapping):
        pass

    class AssociateVpcCidrBlockResult(Mapping):
        pass

    class AttachClassicLinkVpcRequest(Mapping):
        pass

    class AttachClassicLinkVpcResult(Mapping):
        pass

    class AttachInternetGatewayRequest(Mapping):
        pass

    class AttachNetworkInterfaceRequest(Mapping):
        pass

    class AttachNetworkInterfaceResult(Mapping):
        pass

    class AttachVolumeRequest(Mapping):
        pass

    class VolumeAttachment(Mapping):
        pass

    class AttachVpnGatewayRequest(Mapping):
        pass

    class AttachVpnGatewayResult(Mapping):
        pass

    class AuthorizeClientVpnIngressRequest(Mapping):
        pass

    class AuthorizeClientVpnIngressResult(Mapping):
        pass

    class AuthorizeSecurityGroupEgressRequest(Mapping):
        pass

    class IpPermission(Mapping):
        pass

    class AuthorizeSecurityGroupIngressRequest(Mapping):
        pass

    class BundleInstanceRequest(Mapping):
        pass

    class BundleInstanceResult(Mapping):
        pass

    class Storage(Mapping):
        pass

    class CancelBundleTaskRequest(Mapping):
        pass

    class CancelBundleTaskResult(Mapping):
        pass

    class CancelCapacityReservationRequest(Mapping):
        pass

    class CancelCapacityReservationResult(Mapping):
        pass

    class CancelConversionRequest(Mapping):
        pass

    class CancelExportTaskRequest(Mapping):
        pass

    class CancelImportTaskRequest(Mapping):
        pass

    class CancelImportTaskResult(Mapping):
        pass

    class CancelReservedInstancesListingRequest(Mapping):
        pass

    class CancelReservedInstancesListingResult(Mapping):
        pass

    class CancelSpotFleetRequestsRequest(Mapping):
        pass

    class CancelSpotFleetRequestsResponse(Mapping):
        pass

    class CancelSpotInstanceRequestsRequest(Mapping):
        pass

    class CancelSpotInstanceRequestsResult(Mapping):
        pass

    class ConfirmProductInstanceRequest(Mapping):
        pass

    class ConfirmProductInstanceResult(Mapping):
        pass

    class CopyFpgaImageRequest(Mapping):
        pass

    class CopyFpgaImageResult(Mapping):
        pass

    class CopyImageRequest(Mapping):
        pass

    class CopyImageResult(Mapping):
        pass

    class CopySnapshotRequest(Mapping):
        pass

    class CopySnapshotResult(Mapping):
        pass

    class CreateCapacityReservationRequest(Mapping):
        pass

    class CreateCapacityReservationResult(Mapping):
        pass

    class DateTime(object):
        pass

    class CreateClientVpnEndpointRequest(Mapping):
        pass

    class CreateClientVpnEndpointResult(Mapping):
        pass

    class ClientVpnAuthenticationRequest(Mapping):
        pass

    class ConnectionLogOptions(Mapping):
        pass

    class CreateClientVpnRouteRequest(Mapping):
        pass

    class CreateClientVpnRouteResult(Mapping):
        pass

    class CreateCustomerGatewayRequest(Mapping):
        pass

    class CreateCustomerGatewayResult(Mapping):
        pass

    class CreateDefaultSubnetRequest(Mapping):
        pass

    class CreateDefaultSubnetResult(Mapping):
        pass

    class CreateDefaultVpcRequest(Mapping):
        pass

    class CreateDefaultVpcResult(Mapping):
        pass

    class CreateDhcpOptionsRequest(Mapping):
        pass

    class CreateDhcpOptionsResult(Mapping):
        pass

    class NewDhcpConfiguration(Mapping):
        pass

    class CreateEgressOnlyInternetGatewayRequest(Mapping):
        pass

    class CreateEgressOnlyInternetGatewayResult(Mapping):
        pass

    class CreateFleetRequest(Mapping):
        pass

    class CreateFleetResult(Mapping):
        pass

    class SpotOptionsRequest(Mapping):
        pass

    class OnDemandOptionsRequest(Mapping):
        pass

    class FleetLaunchTemplateConfigRequest(Mapping):
        pass

    class TargetCapacitySpecificationRequest(Mapping):
        pass

    class CreateFlowLogsRequest(Mapping):
        pass

    class CreateFlowLogsResult(Mapping):
        pass

    class CreateFpgaImageRequest(Mapping):
        pass

    class CreateFpgaImageResult(Mapping):
        pass

    class StorageLocation(Mapping):
        pass

    class CreateImageRequest(Mapping):
        pass

    class CreateImageResult(Mapping):
        pass

    class BlockDeviceMapping(Mapping):
        pass

    class CreateInstanceExportTaskRequest(Mapping):
        pass

    class CreateInstanceExportTaskResult(Mapping):
        pass

    class ExportToS3TaskSpecification(Mapping):
        pass

    class CreateInternetGatewayRequest(Mapping):
        pass

    class CreateInternetGatewayResult(Mapping):
        pass

    class CreateKeyPairRequest(Mapping):
        pass

    class KeyPair(Mapping):
        pass

    class CreateLaunchTemplateRequest(Mapping):
        pass

    class CreateLaunchTemplateResult(Mapping):
        pass

    class RequestLaunchTemplateData(Mapping):
        pass

    class CreateLaunchTemplateVersionRequest(Mapping):
        pass

    class CreateLaunchTemplateVersionResult(Mapping):
        pass

    class CreateNatGatewayRequest(Mapping):
        pass

    class CreateNatGatewayResult(Mapping):
        pass

    class CreateNetworkAclRequest(Mapping):
        pass

    class CreateNetworkAclResult(Mapping):
        pass

    class CreateNetworkAclEntryRequest(Mapping):
        pass

    class IcmpTypeCode(Mapping):
        pass

    class PortRange(Mapping):
        pass

    class CreateNetworkInterfaceRequest(Mapping):
        pass

    class CreateNetworkInterfaceResult(Mapping):
        pass

    class InstanceIpv6Address(Mapping):
        pass

    class PrivateIpAddressSpecification(Mapping):
        pass

    class CreateNetworkInterfacePermissionRequest(Mapping):
        pass

    class CreateNetworkInterfacePermissionResult(Mapping):
        pass

    class CreatePlacementGroupRequest(Mapping):
        pass

    class CreateReservedInstancesListingRequest(Mapping):
        pass

    class CreateReservedInstancesListingResult(Mapping):
        pass

    class PriceScheduleSpecification(Mapping):
        pass

    class CreateRouteRequest(Mapping):
        pass

    class CreateRouteResult(Mapping):
        pass

    class CreateRouteTableRequest(Mapping):
        pass

    class CreateRouteTableResult(Mapping):
        pass

    class CreateSecurityGroupRequest(Mapping):
        pass

    class CreateSecurityGroupResult(Mapping):
        pass

    class CreateSnapshotRequest(Mapping):
        pass

    class Snapshot(Mapping):
        pass

    class CreateSpotDatafeedSubscriptionRequest(Mapping):
        pass

    class CreateSpotDatafeedSubscriptionResult(Mapping):
        pass

    class CreateSubnetRequest(Mapping):
        pass

    class CreateSubnetResult(Mapping):
        pass

    class CreateTagsRequest(Mapping):
        pass

    class Tag(Mapping):
        pass

    class CreateTransitGatewayRequest(Mapping):
        pass

    class CreateTransitGatewayResult(Mapping):
        pass

    class TransitGatewayRequestOptions(Mapping):
        pass

    class CreateTransitGatewayRouteRequest(Mapping):
        pass

    class CreateTransitGatewayRouteResult(Mapping):
        pass

    class CreateTransitGatewayRouteTableRequest(Mapping):
        pass

    class CreateTransitGatewayRouteTableResult(Mapping):
        pass

    class CreateTransitGatewayVpcAttachmentRequest(Mapping):
        pass

    class CreateTransitGatewayVpcAttachmentResult(Mapping):
        pass

    class CreateTransitGatewayVpcAttachmentRequestOptions(Mapping):
        pass

    class CreateVolumeRequest(Mapping):
        pass

    class Volume(Mapping):
        pass

    class CreateVpcRequest(Mapping):
        pass

    class CreateVpcResult(Mapping):
        pass

    class CreateVpcEndpointRequest(Mapping):
        pass

    class CreateVpcEndpointResult(Mapping):
        pass

    class CreateVpcEndpointConnectionNotificationRequest(Mapping):
        pass

    class CreateVpcEndpointConnectionNotificationResult(Mapping):
        pass

    class CreateVpcEndpointServiceConfigurationRequest(Mapping):
        pass

    class CreateVpcEndpointServiceConfigurationResult(Mapping):
        pass

    class CreateVpcPeeringConnectionRequest(Mapping):
        pass

    class CreateVpcPeeringConnectionResult(Mapping):
        pass

    class CreateVpnConnectionRequest(Mapping):
        pass

    class CreateVpnConnectionResult(Mapping):
        pass

    class VpnConnectionOptionsSpecification(Mapping):
        pass

    class CreateVpnConnectionRouteRequest(Mapping):
        pass

    class CreateVpnGatewayRequest(Mapping):
        pass

    class CreateVpnGatewayResult(Mapping):
        pass

    class Long(object):
        pass

    class DeleteClientVpnEndpointRequest(Mapping):
        pass

    class DeleteClientVpnEndpointResult(Mapping):
        pass

    class DeleteClientVpnRouteRequest(Mapping):
        pass

    class DeleteClientVpnRouteResult(Mapping):
        pass

    class DeleteCustomerGatewayRequest(Mapping):
        pass

    class DeleteDhcpOptionsRequest(Mapping):
        pass

    class DeleteEgressOnlyInternetGatewayRequest(Mapping):
        pass

    class DeleteEgressOnlyInternetGatewayResult(Mapping):
        pass

    class DeleteFleetsRequest(Mapping):
        pass

    class DeleteFleetsResult(Mapping):
        pass

    class FleetIdentifier(object):
        pass

    class DeleteFlowLogsRequest(Mapping):
        pass

    class DeleteFlowLogsResult(Mapping):
        pass

    class DeleteFpgaImageRequest(Mapping):
        pass

    class DeleteFpgaImageResult(Mapping):
        pass

    class DeleteInternetGatewayRequest(Mapping):
        pass

    class DeleteKeyPairRequest(Mapping):
        pass

    class DeleteLaunchTemplateRequest(Mapping):
        pass

    class DeleteLaunchTemplateResult(Mapping):
        pass

    class DeleteLaunchTemplateVersionsRequest(Mapping):
        pass

    class DeleteLaunchTemplateVersionsResult(Mapping):
        pass

    class DeleteNatGatewayRequest(Mapping):
        pass

    class DeleteNatGatewayResult(Mapping):
        pass

    class DeleteNetworkAclRequest(Mapping):
        pass

    class DeleteNetworkAclEntryRequest(Mapping):
        pass

    class DeleteNetworkInterfaceRequest(Mapping):
        pass

    class DeleteNetworkInterfacePermissionRequest(Mapping):
        pass

    class DeleteNetworkInterfacePermissionResult(Mapping):
        pass

    class DeletePlacementGroupRequest(Mapping):
        pass

    class DeleteRouteRequest(Mapping):
        pass

    class DeleteRouteTableRequest(Mapping):
        pass

    class DeleteSecurityGroupRequest(Mapping):
        pass

    class DeleteSnapshotRequest(Mapping):
        pass

    class DeleteSpotDatafeedSubscriptionRequest(Mapping):
        pass

    class DeleteSubnetRequest(Mapping):
        pass

    class DeleteTagsRequest(Mapping):
        pass

    class DeleteTransitGatewayRequest(Mapping):
        pass

    class DeleteTransitGatewayResult(Mapping):
        pass

    class DeleteTransitGatewayRouteRequest(Mapping):
        pass

    class DeleteTransitGatewayRouteResult(Mapping):
        pass

    class DeleteTransitGatewayRouteTableRequest(Mapping):
        pass

    class DeleteTransitGatewayRouteTableResult(Mapping):
        pass

    class DeleteTransitGatewayVpcAttachmentRequest(Mapping):
        pass

    class DeleteTransitGatewayVpcAttachmentResult(Mapping):
        pass

    class DeleteVolumeRequest(Mapping):
        pass

    class DeleteVpcRequest(Mapping):
        pass

    class DeleteVpcEndpointConnectionNotificationsRequest(Mapping):
        pass

    class DeleteVpcEndpointConnectionNotificationsResult(Mapping):
        pass

    class DeleteVpcEndpointServiceConfigurationsRequest(Mapping):
        pass

    class DeleteVpcEndpointServiceConfigurationsResult(Mapping):
        pass

    class DeleteVpcEndpointsRequest(Mapping):
        pass

    class DeleteVpcEndpointsResult(Mapping):
        pass

    class DeleteVpcPeeringConnectionRequest(Mapping):
        pass

    class DeleteVpcPeeringConnectionResult(Mapping):
        pass

    class DeleteVpnConnectionRequest(Mapping):
        pass

    class DeleteVpnConnectionRouteRequest(Mapping):
        pass

    class DeleteVpnGatewayRequest(Mapping):
        pass

    class DeprovisionByoipCidrRequest(Mapping):
        pass

    class DeprovisionByoipCidrResult(Mapping):
        pass

    class DeregisterImageRequest(Mapping):
        pass

    class DescribeAccountAttributesRequest(Mapping):
        pass

    class DescribeAccountAttributesResult(Mapping):
        pass

    class AccountAttributeName(object):
        pass

    class DescribeAddressesRequest(Mapping):
        pass

    class DescribeAddressesResult(Mapping):
        pass

    class Filter(Mapping):
        pass

    class DescribeAggregateIdFormatRequest(Mapping):
        pass

    class DescribeAggregateIdFormatResult(Mapping):
        pass

    class DescribeAvailabilityZonesRequest(Mapping):
        pass

    class DescribeAvailabilityZonesResult(Mapping):
        pass

    class DescribeBundleTasksRequest(Mapping):
        pass

    class DescribeBundleTasksResult(Mapping):
        pass

    class DescribeByoipCidrsRequest(Mapping):
        pass

    class DescribeByoipCidrsResult(Mapping):
        pass

    class DescribeCapacityReservationsRequest(Mapping):
        pass

    class DescribeCapacityReservationsResult(Mapping):
        pass

    class DescribeClassicLinkInstancesRequest(Mapping):
        pass

    class DescribeClassicLinkInstancesResult(Mapping):
        pass

    class DescribeClientVpnAuthorizationRulesRequest(Mapping):
        pass

    class DescribeClientVpnAuthorizationRulesResult(Mapping):
        pass

    class DescribeClientVpnConnectionsRequest(Mapping):
        pass

    class DescribeClientVpnConnectionsResult(Mapping):
        pass

    class DescribeClientVpnEndpointsRequest(Mapping):
        pass

    class DescribeClientVpnEndpointsResult(Mapping):
        pass

    class DescribeClientVpnRoutesRequest(Mapping):
        pass

    class DescribeClientVpnRoutesResult(Mapping):
        pass

    class DescribeClientVpnTargetNetworksRequest(Mapping):
        pass

    class DescribeClientVpnTargetNetworksResult(Mapping):
        pass

    class DescribeConversionTasksRequest(Mapping):
        pass

    class DescribeConversionTasksResult(Mapping):
        pass

    class DescribeCustomerGatewaysRequest(Mapping):
        pass

    class DescribeCustomerGatewaysResult(Mapping):
        pass

    class DescribeDhcpOptionsRequest(Mapping):
        pass

    class DescribeDhcpOptionsResult(Mapping):
        pass

    class DescribeEgressOnlyInternetGatewaysRequest(Mapping):
        pass

    class DescribeEgressOnlyInternetGatewaysResult(Mapping):
        pass

    class EgressOnlyInternetGatewayId(object):
        pass

    class DescribeElasticGpusRequest(Mapping):
        pass

    class DescribeElasticGpusResult(Mapping):
        pass

    class DescribeExportTasksRequest(Mapping):
        pass

    class DescribeExportTasksResult(Mapping):
        pass

    class DescribeFleetHistoryRequest(Mapping):
        pass

    class DescribeFleetHistoryResult(Mapping):
        pass

    class DescribeFleetInstancesRequest(Mapping):
        pass

    class DescribeFleetInstancesResult(Mapping):
        pass

    class DescribeFleetsRequest(Mapping):
        pass

    class DescribeFleetsResult(Mapping):
        pass

    class DescribeFlowLogsRequest(Mapping):
        pass

    class DescribeFlowLogsResult(Mapping):
        pass

    class DescribeFpgaImageAttributeRequest(Mapping):
        pass

    class DescribeFpgaImageAttributeResult(Mapping):
        pass

    class DescribeFpgaImagesRequest(Mapping):
        pass

    class DescribeFpgaImagesResult(Mapping):
        pass

    class DescribeHostReservationOfferingsRequest(Mapping):
        pass

    class DescribeHostReservationOfferingsResult(Mapping):
        pass

    class DescribeHostReservationsRequest(Mapping):
        pass

    class DescribeHostReservationsResult(Mapping):
        pass

    class DescribeHostsRequest(Mapping):
        pass

    class DescribeHostsResult(Mapping):
        pass

    class DescribeIamInstanceProfileAssociationsRequest(Mapping):
        pass

    class DescribeIamInstanceProfileAssociationsResult(Mapping):
        pass

    class DescribeIdFormatRequest(Mapping):
        pass

    class DescribeIdFormatResult(Mapping):
        pass

    class DescribeIdentityIdFormatRequest(Mapping):
        pass

    class DescribeIdentityIdFormatResult(Mapping):
        pass

    class DescribeImageAttributeRequest(Mapping):
        pass

    class ImageAttribute(Mapping):
        pass

    class DescribeImagesRequest(Mapping):
        pass

    class DescribeImagesResult(Mapping):
        pass

    class DescribeImportImageTasksRequest(Mapping):
        pass

    class DescribeImportImageTasksResult(Mapping):
        pass

    class DescribeImportSnapshotTasksRequest(Mapping):
        pass

    class DescribeImportSnapshotTasksResult(Mapping):
        pass

    class DescribeInstanceAttributeRequest(Mapping):
        pass

    class InstanceAttribute(Mapping):
        pass

    class DescribeInstanceCreditSpecificationsRequest(Mapping):
        pass

    class DescribeInstanceCreditSpecificationsResult(Mapping):
        pass

    class DescribeInstanceStatusRequest(Mapping):
        pass

    class DescribeInstanceStatusResult(Mapping):
        pass

    class DescribeInstancesRequest(Mapping):
        pass

    class DescribeInstancesResult(Mapping):
        pass

    class DescribeInternetGatewaysRequest(Mapping):
        pass

    class DescribeInternetGatewaysResult(Mapping):
        pass

    class DescribeKeyPairsRequest(Mapping):
        pass

    class DescribeKeyPairsResult(Mapping):
        pass

    class DescribeLaunchTemplateVersionsRequest(Mapping):
        pass

    class DescribeLaunchTemplateVersionsResult(Mapping):
        pass

    class DescribeLaunchTemplatesRequest(Mapping):
        pass

    class DescribeLaunchTemplatesResult(Mapping):
        pass

    class LaunchTemplateName(object):
        pass

    class DescribeMovingAddressesRequest(Mapping):
        pass

    class DescribeMovingAddressesResult(Mapping):
        pass

    class DescribeNatGatewaysRequest(Mapping):
        pass

    class DescribeNatGatewaysResult(Mapping):
        pass

    class DescribeNetworkAclsRequest(Mapping):
        pass

    class DescribeNetworkAclsResult(Mapping):
        pass

    class DescribeNetworkInterfaceAttributeRequest(Mapping):
        pass

    class DescribeNetworkInterfaceAttributeResult(Mapping):
        pass

    class DescribeNetworkInterfacePermissionsRequest(Mapping):
        pass

    class DescribeNetworkInterfacePermissionsResult(Mapping):
        pass

    class DescribeNetworkInterfacesRequest(Mapping):
        pass

    class DescribeNetworkInterfacesResult(Mapping):
        pass

    class DescribePlacementGroupsRequest(Mapping):
        pass

    class DescribePlacementGroupsResult(Mapping):
        pass

    class DescribePrefixListsRequest(Mapping):
        pass

    class DescribePrefixListsResult(Mapping):
        pass

    class DescribePrincipalIdFormatRequest(Mapping):
        pass

    class DescribePrincipalIdFormatResult(Mapping):
        pass

    class DescribePublicIpv4PoolsRequest(Mapping):
        pass

    class DescribePublicIpv4PoolsResult(Mapping):
        pass

    class DescribeRegionsRequest(Mapping):
        pass

    class DescribeRegionsResult(Mapping):
        pass

    class DescribeReservedInstancesRequest(Mapping):
        pass

    class DescribeReservedInstancesResult(Mapping):
        pass

    class DescribeReservedInstancesListingsRequest(Mapping):
        pass

    class DescribeReservedInstancesListingsResult(Mapping):
        pass

    class DescribeReservedInstancesModificationsRequest(Mapping):
        pass

    class DescribeReservedInstancesModificationsResult(Mapping):
        pass

    class DescribeReservedInstancesOfferingsRequest(Mapping):
        pass

    class DescribeReservedInstancesOfferingsResult(Mapping):
        pass

    class DescribeRouteTablesRequest(Mapping):
        pass

    class DescribeRouteTablesResult(Mapping):
        pass

    class DescribeScheduledInstanceAvailabilityRequest(Mapping):
        pass

    class DescribeScheduledInstanceAvailabilityResult(Mapping):
        pass

    class SlotDateTimeRangeRequest(Mapping):
        pass

    class ScheduledInstanceRecurrenceRequest(Mapping):
        pass

    class DescribeScheduledInstancesRequest(Mapping):
        pass

    class DescribeScheduledInstancesResult(Mapping):
        pass

    class SlotStartTimeRangeRequest(Mapping):
        pass

    class DescribeSecurityGroupReferencesRequest(Mapping):
        pass

    class DescribeSecurityGroupReferencesResult(Mapping):
        pass

    class DescribeSecurityGroupsRequest(Mapping):
        pass

    class DescribeSecurityGroupsResult(Mapping):
        pass

    class DescribeSnapshotAttributeRequest(Mapping):
        pass

    class DescribeSnapshotAttributeResult(Mapping):
        pass

    class DescribeSnapshotsRequest(Mapping):
        pass

    class DescribeSnapshotsResult(Mapping):
        pass

    class DescribeSpotDatafeedSubscriptionRequest(Mapping):
        pass

    class DescribeSpotDatafeedSubscriptionResult(Mapping):
        pass

    class DescribeSpotFleetInstancesRequest(Mapping):
        pass

    class DescribeSpotFleetInstancesResponse(Mapping):
        pass

    class DescribeSpotFleetRequestHistoryRequest(Mapping):
        pass

    class DescribeSpotFleetRequestHistoryResponse(Mapping):
        pass

    class DescribeSpotFleetRequestsRequest(Mapping):
        pass

    class DescribeSpotFleetRequestsResponse(Mapping):
        pass

    class DescribeSpotInstanceRequestsRequest(Mapping):
        pass

    class DescribeSpotInstanceRequestsResult(Mapping):
        pass

    class DescribeSpotPriceHistoryRequest(Mapping):
        pass

    class DescribeSpotPriceHistoryResult(Mapping):
        pass

    class InstanceType(object):
        pass

    class DescribeStaleSecurityGroupsRequest(Mapping):
        pass

    class DescribeStaleSecurityGroupsResult(Mapping):
        pass

    class DescribeSubnetsRequest(Mapping):
        pass

    class DescribeSubnetsResult(Mapping):
        pass

    class DescribeTagsRequest(Mapping):
        pass

    class DescribeTagsResult(Mapping):
        pass

    class DescribeTransitGatewayAttachmentsRequest(Mapping):
        pass

    class DescribeTransitGatewayAttachmentsResult(Mapping):
        pass

    class DescribeTransitGatewayRouteTablesRequest(Mapping):
        pass

    class DescribeTransitGatewayRouteTablesResult(Mapping):
        pass

    class DescribeTransitGatewayVpcAttachmentsRequest(Mapping):
        pass

    class DescribeTransitGatewayVpcAttachmentsResult(Mapping):
        pass

    class DescribeTransitGatewaysRequest(Mapping):
        pass

    class DescribeTransitGatewaysResult(Mapping):
        pass

    class DescribeVolumeAttributeRequest(Mapping):
        pass

    class DescribeVolumeAttributeResult(Mapping):
        pass

    class DescribeVolumeStatusRequest(Mapping):
        pass

    class DescribeVolumeStatusResult(Mapping):
        pass

    class DescribeVolumesRequest(Mapping):
        pass

    class DescribeVolumesResult(Mapping):
        pass

    class DescribeVolumesModificationsRequest(Mapping):
        pass

    class DescribeVolumesModificationsResult(Mapping):
        pass

    class DescribeVpcAttributeRequest(Mapping):
        pass

    class DescribeVpcAttributeResult(Mapping):
        pass

    class DescribeVpcClassicLinkRequest(Mapping):
        pass

    class DescribeVpcClassicLinkResult(Mapping):
        pass

    class DescribeVpcClassicLinkDnsSupportRequest(Mapping):
        pass

    class DescribeVpcClassicLinkDnsSupportResult(Mapping):
        pass

    class DescribeVpcEndpointConnectionNotificationsRequest(Mapping):
        pass

    class DescribeVpcEndpointConnectionNotificationsResult(Mapping):
        pass

    class DescribeVpcEndpointConnectionsRequest(Mapping):
        pass

    class DescribeVpcEndpointConnectionsResult(Mapping):
        pass

    class DescribeVpcEndpointServiceConfigurationsRequest(Mapping):
        pass

    class DescribeVpcEndpointServiceConfigurationsResult(Mapping):
        pass

    class DescribeVpcEndpointServicePermissionsRequest(Mapping):
        pass

    class DescribeVpcEndpointServicePermissionsResult(Mapping):
        pass

    class DescribeVpcEndpointServicesRequest(Mapping):
        pass

    class DescribeVpcEndpointServicesResult(Mapping):
        pass

    class DescribeVpcEndpointsRequest(Mapping):
        pass

    class DescribeVpcEndpointsResult(Mapping):
        pass

    class DescribeVpcPeeringConnectionsRequest(Mapping):
        pass

    class DescribeVpcPeeringConnectionsResult(Mapping):
        pass

    class DescribeVpcsRequest(Mapping):
        pass

    class DescribeVpcsResult(Mapping):
        pass

    class DescribeVpnConnectionsRequest(Mapping):
        pass

    class DescribeVpnConnectionsResult(Mapping):
        pass

    class DescribeVpnGatewaysRequest(Mapping):
        pass

    class DescribeVpnGatewaysResult(Mapping):
        pass

    class DetachClassicLinkVpcRequest(Mapping):
        pass

    class DetachClassicLinkVpcResult(Mapping):
        pass

    class DetachInternetGatewayRequest(Mapping):
        pass

    class DetachNetworkInterfaceRequest(Mapping):
        pass

    class DetachVolumeRequest(Mapping):
        pass

    class DetachVpnGatewayRequest(Mapping):
        pass

    class DisableTransitGatewayRouteTablePropagationRequest(Mapping):
        pass

    class DisableTransitGatewayRouteTablePropagationResult(Mapping):
        pass

    class DisableVgwRoutePropagationRequest(Mapping):
        pass

    class DisableVpcClassicLinkRequest(Mapping):
        pass

    class DisableVpcClassicLinkResult(Mapping):
        pass

    class DisableVpcClassicLinkDnsSupportRequest(Mapping):
        pass

    class DisableVpcClassicLinkDnsSupportResult(Mapping):
        pass

    class DisassociateAddressRequest(Mapping):
        pass

    class DisassociateClientVpnTargetNetworkRequest(Mapping):
        pass

    class DisassociateClientVpnTargetNetworkResult(Mapping):
        pass

    class DisassociateIamInstanceProfileRequest(Mapping):
        pass

    class DisassociateIamInstanceProfileResult(Mapping):
        pass

    class DisassociateRouteTableRequest(Mapping):
        pass

    class DisassociateSubnetCidrBlockRequest(Mapping):
        pass

    class DisassociateSubnetCidrBlockResult(Mapping):
        pass

    class DisassociateTransitGatewayRouteTableRequest(Mapping):
        pass

    class DisassociateTransitGatewayRouteTableResult(Mapping):
        pass

    class DisassociateVpcCidrBlockRequest(Mapping):
        pass

    class DisassociateVpcCidrBlockResult(Mapping):
        pass

    class EnableTransitGatewayRouteTablePropagationRequest(Mapping):
        pass

    class EnableTransitGatewayRouteTablePropagationResult(Mapping):
        pass

    class EnableVgwRoutePropagationRequest(Mapping):
        pass

    class EnableVolumeIORequest(Mapping):
        pass

    class EnableVpcClassicLinkRequest(Mapping):
        pass

    class EnableVpcClassicLinkResult(Mapping):
        pass

    class EnableVpcClassicLinkDnsSupportRequest(Mapping):
        pass

    class EnableVpcClassicLinkDnsSupportResult(Mapping):
        pass

    class ExportClientVpnClientCertificateRevocationListRequest(Mapping):
        pass

    class ExportClientVpnClientCertificateRevocationListResult(Mapping):
        pass

    class ExportClientVpnClientConfigurationRequest(Mapping):
        pass

    class ExportClientVpnClientConfigurationResult(Mapping):
        pass

    class ExportTransitGatewayRoutesRequest(Mapping):
        pass

    class ExportTransitGatewayRoutesResult(Mapping):
        pass

    class GetConsoleOutputRequest(Mapping):
        pass

    class GetConsoleOutputResult(Mapping):
        pass

    class GetConsoleScreenshotRequest(Mapping):
        pass

    class GetConsoleScreenshotResult(Mapping):
        pass

    class GetHostReservationPurchasePreviewRequest(Mapping):
        pass

    class GetHostReservationPurchasePreviewResult(Mapping):
        pass

    class GetLaunchTemplateDataRequest(Mapping):
        pass

    class GetLaunchTemplateDataResult(Mapping):
        pass

    class GetPasswordDataRequest(Mapping):
        pass

    class GetPasswordDataResult(Mapping):
        pass

    class GetReservedInstancesExchangeQuoteRequest(Mapping):
        pass

    class GetReservedInstancesExchangeQuoteResult(Mapping):
        pass

    class GetTransitGatewayAttachmentPropagationsRequest(Mapping):
        pass

    class GetTransitGatewayAttachmentPropagationsResult(Mapping):
        pass

    class GetTransitGatewayRouteTableAssociationsRequest(Mapping):
        pass

    class GetTransitGatewayRouteTableAssociationsResult(Mapping):
        pass

    class GetTransitGatewayRouteTablePropagationsRequest(Mapping):
        pass

    class GetTransitGatewayRouteTablePropagationsResult(Mapping):
        pass

    class ImportClientVpnClientCertificateRevocationListRequest(Mapping):
        pass

    class ImportClientVpnClientCertificateRevocationListResult(Mapping):
        pass

    class ImportImageRequest(Mapping):
        pass

    class ImportImageResult(Mapping):
        pass

    class ClientData(Mapping):
        pass

    class ImageDiskContainer(Mapping):
        pass

    class ImportInstanceRequest(Mapping):
        pass

    class ImportInstanceResult(Mapping):
        pass

    class DiskImage(Mapping):
        pass

    class ImportInstanceLaunchSpecification(Mapping):
        pass

    class ImportKeyPairRequest(Mapping):
        pass

    class ImportKeyPairResult(Mapping):
        pass

    class Blob(object):
        pass

    class ImportSnapshotRequest(Mapping):
        pass

    class ImportSnapshotResult(Mapping):
        pass

    class SnapshotDiskContainer(Mapping):
        pass

    class ImportVolumeRequest(Mapping):
        pass

    class ImportVolumeResult(Mapping):
        pass

    class DiskImageDetail(Mapping):
        pass

    class VolumeDetail(Mapping):
        pass

    class ModifyCapacityReservationRequest(Mapping):
        pass

    class ModifyCapacityReservationResult(Mapping):
        pass

    class ModifyClientVpnEndpointRequest(Mapping):
        pass

    class ModifyClientVpnEndpointResult(Mapping):
        pass

    class DnsServersOptionsModifyStructure(Mapping):
        pass

    class ModifyFleetRequest(Mapping):
        pass

    class ModifyFleetResult(Mapping):
        pass

    class ModifyFpgaImageAttributeRequest(Mapping):
        pass

    class ModifyFpgaImageAttributeResult(Mapping):
        pass

    class LoadPermissionModifications(Mapping):
        pass

    class ModifyHostsRequest(Mapping):
        pass

    class ModifyHostsResult(Mapping):
        pass

    class ModifyIdFormatRequest(Mapping):
        pass

    class ModifyIdentityIdFormatRequest(Mapping):
        pass

    class ModifyImageAttributeRequest(Mapping):
        pass

    class AttributeValue(Mapping):
        pass

    class LaunchPermissionModifications(Mapping):
        pass

    class ModifyInstanceAttributeRequest(Mapping):
        pass

    class AttributeBooleanValue(Mapping):
        pass

    class InstanceBlockDeviceMappingSpecification(Mapping):
        pass

    class BlobAttributeValue(Mapping):
        pass

    class ModifyInstanceCapacityReservationAttributesRequest(Mapping):
        pass

    class ModifyInstanceCapacityReservationAttributesResult(Mapping):
        pass

    class CapacityReservationSpecification(Mapping):
        pass

    class ModifyInstanceCreditSpecificationRequest(Mapping):
        pass

    class ModifyInstanceCreditSpecificationResult(Mapping):
        pass

    class InstanceCreditSpecificationRequest(Mapping):
        pass

    class ModifyInstancePlacementRequest(Mapping):
        pass

    class ModifyInstancePlacementResult(Mapping):
        pass

    class ModifyLaunchTemplateRequest(Mapping):
        pass

    class ModifyLaunchTemplateResult(Mapping):
        pass

    class ModifyNetworkInterfaceAttributeRequest(Mapping):
        pass

    class NetworkInterfaceAttachmentChanges(Mapping):
        pass

    class ModifyReservedInstancesRequest(Mapping):
        pass

    class ModifyReservedInstancesResult(Mapping):
        pass

    class ReservedInstancesConfiguration(Mapping):
        pass

    class ModifySnapshotAttributeRequest(Mapping):
        pass

    class CreateVolumePermissionModifications(Mapping):
        pass

    class ModifySpotFleetRequestRequest(Mapping):
        pass

    class ModifySpotFleetRequestResponse(Mapping):
        pass

    class ModifySubnetAttributeRequest(Mapping):
        pass

    class ModifyTransitGatewayVpcAttachmentRequest(Mapping):
        pass

    class ModifyTransitGatewayVpcAttachmentResult(Mapping):
        pass

    class ModifyTransitGatewayVpcAttachmentRequestOptions(Mapping):
        pass

    class ModifyVolumeRequest(Mapping):
        pass

    class ModifyVolumeResult(Mapping):
        pass

    class ModifyVolumeAttributeRequest(Mapping):
        pass

    class ModifyVpcAttributeRequest(Mapping):
        pass

    class ModifyVpcEndpointRequest(Mapping):
        pass

    class ModifyVpcEndpointResult(Mapping):
        pass

    class ModifyVpcEndpointConnectionNotificationRequest(Mapping):
        pass

    class ModifyVpcEndpointConnectionNotificationResult(Mapping):
        pass

    class ModifyVpcEndpointServiceConfigurationRequest(Mapping):
        pass

    class ModifyVpcEndpointServiceConfigurationResult(Mapping):
        pass

    class ModifyVpcEndpointServicePermissionsRequest(Mapping):
        pass

    class ModifyVpcEndpointServicePermissionsResult(Mapping):
        pass

    class ModifyVpcPeeringConnectionOptionsRequest(Mapping):
        pass

    class ModifyVpcPeeringConnectionOptionsResult(Mapping):
        pass

    class PeeringConnectionOptionsRequest(Mapping):
        pass

    class ModifyVpcTenancyRequest(Mapping):
        pass

    class ModifyVpcTenancyResult(Mapping):
        pass

    class MonitorInstancesRequest(Mapping):
        pass

    class MonitorInstancesResult(Mapping):
        pass

    class MoveAddressToVpcRequest(Mapping):
        pass

    class MoveAddressToVpcResult(Mapping):
        pass

    class ProvisionByoipCidrRequest(Mapping):
        pass

    class ProvisionByoipCidrResult(Mapping):
        pass

    class CidrAuthorizationContext(Mapping):
        pass

    class PurchaseHostReservationRequest(Mapping):
        pass

    class PurchaseHostReservationResult(Mapping):
        pass

    class PurchaseReservedInstancesOfferingRequest(Mapping):
        pass

    class PurchaseReservedInstancesOfferingResult(Mapping):
        pass

    class ReservedInstanceLimitPrice(Mapping):
        pass

    class PurchaseScheduledInstancesRequest(Mapping):
        pass

    class PurchaseScheduledInstancesResult(Mapping):
        pass

    class PurchaseRequest(Mapping):
        pass

    class RebootInstancesRequest(Mapping):
        pass

    class RegisterImageRequest(Mapping):
        pass

    class RegisterImageResult(Mapping):
        pass

    class RejectTransitGatewayVpcAttachmentRequest(Mapping):
        pass

    class RejectTransitGatewayVpcAttachmentResult(Mapping):
        pass

    class RejectVpcEndpointConnectionsRequest(Mapping):
        pass

    class RejectVpcEndpointConnectionsResult(Mapping):
        pass

    class RejectVpcPeeringConnectionRequest(Mapping):
        pass

    class RejectVpcPeeringConnectionResult(Mapping):
        pass

    class ReleaseAddressRequest(Mapping):
        pass

    class ReleaseHostsRequest(Mapping):
        pass

    class ReleaseHostsResult(Mapping):
        pass

    class ReplaceIamInstanceProfileAssociationRequest(Mapping):
        pass

    class ReplaceIamInstanceProfileAssociationResult(Mapping):
        pass

    class ReplaceNetworkAclAssociationRequest(Mapping):
        pass

    class ReplaceNetworkAclAssociationResult(Mapping):
        pass

    class ReplaceNetworkAclEntryRequest(Mapping):
        pass

    class ReplaceRouteRequest(Mapping):
        pass

    class ReplaceRouteTableAssociationRequest(Mapping):
        pass

    class ReplaceRouteTableAssociationResult(Mapping):
        pass

    class ReplaceTransitGatewayRouteRequest(Mapping):
        pass

    class ReplaceTransitGatewayRouteResult(Mapping):
        pass

    class ReportInstanceStatusRequest(Mapping):
        pass

    class ReportInstanceReasonCodes(object):
        pass

    class RequestSpotFleetRequest(Mapping):
        pass

    class RequestSpotFleetResponse(Mapping):
        pass

    class SpotFleetRequestConfigData(Mapping):
        pass

    class RequestSpotInstancesRequest(Mapping):
        pass

    class RequestSpotInstancesResult(Mapping):
        pass

    class RequestSpotLaunchSpecification(Mapping):
        pass

    class ResetFpgaImageAttributeRequest(Mapping):
        pass

    class ResetFpgaImageAttributeResult(Mapping):
        pass

    class ResetImageAttributeRequest(Mapping):
        pass

    class ResetInstanceAttributeRequest(Mapping):
        pass

    class ResetNetworkInterfaceAttributeRequest(Mapping):
        pass

    class ResetSnapshotAttributeRequest(Mapping):
        pass

    class RestoreAddressToClassicRequest(Mapping):
        pass

    class RestoreAddressToClassicResult(Mapping):
        pass

    class RevokeClientVpnIngressRequest(Mapping):
        pass

    class RevokeClientVpnIngressResult(Mapping):
        pass

    class RevokeSecurityGroupEgressRequest(Mapping):
        pass

    class RevokeSecurityGroupIngressRequest(Mapping):
        pass

    class RunInstancesRequest(Mapping):
        pass

    class Reservation(Mapping):
        pass

    class RunInstancesMonitoringEnabled(Mapping):
        pass

    class Placement(Mapping):
        pass

    class InstanceNetworkInterfaceSpecification(Mapping):
        pass

    class ElasticGpuSpecification(Mapping):
        pass

    class ElasticInferenceAccelerator(Mapping):
        pass

    class LaunchTemplateSpecification(Mapping):
        pass

    class InstanceMarketOptionsRequest(Mapping):
        pass

    class CreditSpecificationRequest(Mapping):
        pass

    class CpuOptionsRequest(Mapping):
        pass

    class HibernationOptionsRequest(Mapping):
        pass

    class LicenseConfigurationRequest(Mapping):
        pass

    class RunScheduledInstancesRequest(Mapping):
        pass

    class RunScheduledInstancesResult(Mapping):
        pass

    class ScheduledInstancesLaunchSpecification(Mapping):
        pass

    class SearchTransitGatewayRoutesRequest(Mapping):
        pass

    class SearchTransitGatewayRoutesResult(Mapping):
        pass

    class StartInstancesRequest(Mapping):
        pass

    class StartInstancesResult(Mapping):
        pass

    class StopInstancesRequest(Mapping):
        pass

    class StopInstancesResult(Mapping):
        pass

    class TerminateClientVpnConnectionsRequest(Mapping):
        pass

    class TerminateClientVpnConnectionsResult(Mapping):
        pass

    class TerminateInstancesRequest(Mapping):
        pass

    class TerminateInstancesResult(Mapping):
        pass

    class UnassignIpv6AddressesRequest(Mapping):
        pass

    class UnassignIpv6AddressesResult(Mapping):
        pass

    class UnassignPrivateIpAddressesRequest(Mapping):
        pass

    class UnmonitorInstancesRequest(Mapping):
        pass

    class UnmonitorInstancesResult(Mapping):
        pass

    class UpdateSecurityGroupRuleDescriptionsEgressRequest(Mapping):
        pass

    class UpdateSecurityGroupRuleDescriptionsEgressResult(Mapping):
        pass

    class UpdateSecurityGroupRuleDescriptionsIngressRequest(Mapping):
        pass

    class UpdateSecurityGroupRuleDescriptionsIngressResult(Mapping):
        pass

    class WithdrawByoipCidrRequest(Mapping):
        pass

    class WithdrawByoipCidrResult(Mapping):
        pass

    def accept_reserved_instances_exchange_quote(self, ReservedInstanceIds: List[String], DryRun: Boolean=None, TargetConfigurations: List[TargetConfigurationRequest]=None) -> AcceptReservedInstancesExchangeQuoteResult:
        pass

    def accept_transit_gateway_vpc_attachment(self, TransitGatewayAttachmentId: str, DryRun: Boolean=None) -> AcceptTransitGatewayVpcAttachmentResult:
        pass

    def accept_vpc_endpoint_connections(self, VpcEndpointIds: List[String], ServiceId: str, DryRun: Boolean=None) -> AcceptVpcEndpointConnectionsResult:
        pass

    def accept_vpc_peering_connection(self, DryRun: Boolean=None, VpcPeeringConnectionId: str=None) -> AcceptVpcPeeringConnectionResult:
        pass

    def advertise_byoip_cidr(self, Cidr: str, DryRun: Boolean=None) -> AdvertiseByoipCidrResult:
        pass

    def allocate_address(self, Domain: str=None, Address: str=None, PublicIpv4Pool: str=None, DryRun: Boolean=None) -> AllocateAddressResult:
        pass

    def allocate_hosts(self, Quantity: int, InstanceType: str, AvailabilityZone: str, AutoPlacement: str=None, ClientToken: str=None, TagSpecifications: List[TagSpecification]=None) -> AllocateHostsResult:
        pass

    def apply_security_groups_to_client_vpn_target_network(self, SecurityGroupIds: List[String], VpcId: str, ClientVpnEndpointId: str, DryRun: Boolean=None) -> ApplySecurityGroupsToClientVpnTargetNetworkResult:
        pass

    def assign_ipv6_addresses(self, NetworkInterfaceId: str, Ipv6AddressCount: int=None, Ipv6Addresses: List[String]=None) -> AssignIpv6AddressesResult:
        pass

    def assign_private_ip_addresses(self, NetworkInterfaceId: str, AllowReassignment: Boolean=None, PrivateIpAddresses: List[String]=None, SecondaryPrivateIpAddressCount: int=None):
        pass

    def associate_address(self, AllocationId: str=None, InstanceId: str=None, PublicIp: str=None, AllowReassociation: Boolean=None, DryRun: Boolean=None, NetworkInterfaceId: str=None, PrivateIpAddress: str=None) -> AssociateAddressResult:
        pass

    def associate_client_vpn_target_network(self, SubnetId: str, ClientVpnEndpointId: str, DryRun: Boolean=None) -> AssociateClientVpnTargetNetworkResult:
        pass

    def associate_dhcp_options(self, VpcId: str, DhcpOptionsId: str, DryRun: Boolean=None):
        pass

    def associate_iam_instance_profile(self, InstanceId: str, IamInstanceProfile: IamInstanceProfileSpecification) -> AssociateIamInstanceProfileResult:
        pass

    def associate_route_table(self, SubnetId: str, RouteTableId: str, DryRun: Boolean=None) -> AssociateRouteTableResult:
        pass

    def associate_subnet_cidr_block(self, SubnetId: str, Ipv6CidrBlock: str) -> AssociateSubnetCidrBlockResult:
        pass

    def associate_transit_gateway_route_table(self, TransitGatewayAttachmentId: str, TransitGatewayRouteTableId: str, DryRun: Boolean=None) -> AssociateTransitGatewayRouteTableResult:
        pass

    def associate_vpc_cidr_block(self, VpcId: str, AmazonProvidedIpv6CidrBlock: Boolean=None, CidrBlock: str=None) -> AssociateVpcCidrBlockResult:
        pass

    def attach_classic_link_vpc(self, VpcId: str, InstanceId: str, Groups: List[String], DryRun: Boolean=None) -> AttachClassicLinkVpcResult:
        pass

    def attach_internet_gateway(self, VpcId: str, InternetGatewayId: str, DryRun: Boolean=None):
        pass

    def attach_network_interface(self, NetworkInterfaceId: str, InstanceId: str, DeviceIndex: int, DryRun: Boolean=None) -> AttachNetworkInterfaceResult:
        pass

    def attach_volume(self, VolumeId: str, InstanceId: str, Device: str, DryRun: Boolean=None) -> VolumeAttachment:
        pass

    def attach_vpn_gateway(self, VpnGatewayId: str, VpcId: str, DryRun: Boolean=None) -> AttachVpnGatewayResult:
        pass

    def authorize_client_vpn_ingress(self, TargetNetworkCidr: str, ClientVpnEndpointId: str, AccessGroupId: str=None, AuthorizeAllGroups: Boolean=None, Description: str=None, DryRun: Boolean=None) -> AuthorizeClientVpnIngressResult:
        pass

    def authorize_security_group_egress(self, GroupId: str, DryRun: Boolean=None, IpPermissions: List[IpPermission]=None, CidrIp: str=None, FromPort: int=None, IpProtocol: str=None, ToPort: int=None, SourceSecurityGroupName: str=None, SourceSecurityGroupOwnerId: str=None):
        pass

    def authorize_security_group_ingress(self, CidrIp: str=None, FromPort: int=None, GroupId: str=None, GroupName: str=None, IpPermissions: List[IpPermission]=None, IpProtocol: str=None, SourceSecurityGroupName: str=None, SourceSecurityGroupOwnerId: str=None, ToPort: int=None, DryRun: Boolean=None):
        pass

    def bundle_instance(self, Storage: Storage, InstanceId: str, DryRun: Boolean=None) -> BundleInstanceResult:
        pass

    def cancel_bundle_task(self, BundleId: str, DryRun: Boolean=None) -> CancelBundleTaskResult:
        pass

    def cancel_capacity_reservation(self, CapacityReservationId: str, DryRun: Boolean=None) -> CancelCapacityReservationResult:
        pass

    def cancel_conversion_task(self, ConversionTaskId: str, DryRun: Boolean=None, ReasonMessage: str=None):
        pass

    def cancel_export_task(self, ExportTaskId: str):
        pass

    def cancel_import_task(self, CancelReason: str=None, DryRun: Boolean=None, ImportTaskId: str=None) -> CancelImportTaskResult:
        pass

    def cancel_reserved_instances_listing(self, ReservedInstancesListingId: str) -> CancelReservedInstancesListingResult:
        pass

    def cancel_spot_fleet_requests(self, TerminateInstances: Boolean, SpotFleetRequestIds: List[String], DryRun: Boolean=None) -> CancelSpotFleetRequestsResponse:
        pass

    def cancel_spot_instance_requests(self, SpotInstanceRequestIds: List[String], DryRun: Boolean=None) -> CancelSpotInstanceRequestsResult:
        pass

    def confirm_product_instance(self, ProductCode: str, InstanceId: str, DryRun: Boolean=None) -> ConfirmProductInstanceResult:
        pass

    def copy_fpga_image(self, SourceRegion: str, SourceFpgaImageId: str, DryRun: Boolean=None, Description: str=None, Name: str=None, ClientToken: str=None) -> CopyFpgaImageResult:
        pass

    def copy_image(self, SourceRegion: str, SourceImageId: str, Name: str, ClientToken: str=None, Description: str=None, Encrypted: Boolean=None, KmsKeyId: str=None, DryRun: Boolean=None) -> CopyImageResult:
        pass

    def copy_snapshot(self, SourceSnapshotId: str, SourceRegion: str, Description: str=None, DestinationRegion: str=None, Encrypted: Boolean=None, KmsKeyId: str=None, PresignedUrl: str=None, DryRun: Boolean=None) -> CopySnapshotResult:
        pass

    def create_capacity_reservation(self, InstanceCount: int, AvailabilityZone: str, InstancePlatform: str, InstanceType: str, ClientToken: str=None, Tenancy: str=None, EbsOptimized: Boolean=None, EphemeralStorage: Boolean=None, EndDate: DateTime=None, EndDateType: str=None, InstanceMatchCriteria: str=None, TagSpecifications: List[TagSpecification]=None, DryRun: Boolean=None) -> CreateCapacityReservationResult:
        pass

    def create_client_vpn_endpoint(self, ConnectionLogOptions: ConnectionLogOptions, AuthenticationOptions: List[ClientVpnAuthenticationRequest], ServerCertificateArn: str, ClientCidrBlock: str, DnsServers: List[String]=None, TransportProtocol: str=None, Description: str=None, DryRun: Boolean=None, ClientToken: str=None) -> CreateClientVpnEndpointResult:
        pass

    def create_client_vpn_route(self, TargetVpcSubnetId: str, DestinationCidrBlock: str, ClientVpnEndpointId: str, Description: str=None, DryRun: Boolean=None) -> CreateClientVpnRouteResult:
        pass

    def create_customer_gateway(self, Type: str, PublicIp: str, BgpAsn: int, DryRun: Boolean=None) -> CreateCustomerGatewayResult:
        pass

    def create_default_subnet(self, AvailabilityZone: str, DryRun: Boolean=None) -> CreateDefaultSubnetResult:
        pass

    def create_default_vpc(self, DryRun: Boolean=None) -> CreateDefaultVpcResult:
        pass

    def create_dhcp_options(self, DhcpConfigurations: List[NewDhcpConfiguration], DryRun: Boolean=None) -> CreateDhcpOptionsResult:
        pass

    def create_egress_only_internet_gateway(self, VpcId: str, ClientToken: str=None, DryRun: Boolean=None) -> CreateEgressOnlyInternetGatewayResult:
        pass

    def create_fleet(self, TargetCapacitySpecification: TargetCapacitySpecificationRequest, LaunchTemplateConfigs: List[FleetLaunchTemplateConfigRequest], DryRun: Boolean=None, ClientToken: str=None, SpotOptions: SpotOptionsRequest=None, OnDemandOptions: OnDemandOptionsRequest=None, ExcessCapacityTerminationPolicy: str=None, TerminateInstancesWithExpiration: Boolean=None, Type: str=None, ValidFrom: DateTime=None, ValidUntil: DateTime=None, ReplaceUnhealthyInstances: Boolean=None, TagSpecifications: List[TagSpecification]=None) -> CreateFleetResult:
        pass

    def create_flow_logs(self, TrafficType: str, ResourceType: str, ResourceIds: List[String], DryRun: Boolean=None, ClientToken: str=None, DeliverLogsPermissionArn: str=None, LogGroupName: str=None, LogDestinationType: str=None, LogDestination: str=None) -> CreateFlowLogsResult:
        pass

    def create_fpga_image(self, InputStorageLocation: StorageLocation, DryRun: Boolean=None, LogsStorageLocation: StorageLocation=None, Description: str=None, Name: str=None, ClientToken: str=None) -> CreateFpgaImageResult:
        pass

    def create_image(self, Name: str, InstanceId: str, BlockDeviceMappings: List[BlockDeviceMapping]=None, Description: str=None, DryRun: Boolean=None, NoReboot: Boolean=None) -> CreateImageResult:
        pass

    def create_instance_export_task(self, InstanceId: str, Description: str=None, ExportToS3Task: ExportToS3TaskSpecification=None, TargetEnvironment: str=None) -> CreateInstanceExportTaskResult:
        pass

    def create_internet_gateway(self, DryRun: Boolean=None) -> CreateInternetGatewayResult:
        pass

    def create_key_pair(self, KeyName: str, DryRun: Boolean=None) -> KeyPair:
        pass

    def create_launch_template(self, LaunchTemplateData: RequestLaunchTemplateData, LaunchTemplateName: str, DryRun: Boolean=None, ClientToken: str=None, VersionDescription: str=None) -> CreateLaunchTemplateResult:
        pass

    def create_launch_template_version(self, LaunchTemplateData: RequestLaunchTemplateData, DryRun: Boolean=None, ClientToken: str=None, LaunchTemplateId: str=None, LaunchTemplateName: str=None, SourceVersion: str=None, VersionDescription: str=None) -> CreateLaunchTemplateVersionResult:
        pass

    def create_nat_gateway(self, SubnetId: str, AllocationId: str, ClientToken: str=None) -> CreateNatGatewayResult:
        pass

    def create_network_acl(self, VpcId: str, DryRun: Boolean=None) -> CreateNetworkAclResult:
        pass

    def create_network_acl_entry(self, RuleNumber: int, RuleAction: str, Protocol: str, NetworkAclId: str, Egress: Boolean, CidrBlock: str=None, DryRun: Boolean=None, IcmpTypeCode: IcmpTypeCode=None, Ipv6CidrBlock: str=None, PortRange: PortRange=None):
        pass

    def create_network_interface(self, SubnetId: str, Description: str=None, DryRun: Boolean=None, Groups: List[String]=None, Ipv6AddressCount: int=None, Ipv6Addresses: List[InstanceIpv6Address]=None, PrivateIpAddress: str=None, PrivateIpAddresses: List[PrivateIpAddressSpecification]=None, SecondaryPrivateIpAddressCount: int=None) -> CreateNetworkInterfaceResult:
        pass

    def create_network_interface_permission(self, Permission: str, NetworkInterfaceId: str, AwsAccountId: str=None, AwsService: str=None, DryRun: Boolean=None) -> CreateNetworkInterfacePermissionResult:
        pass

    def create_placement_group(self, DryRun: Boolean=None, GroupName: str=None, Strategy: str=None, PartitionCount: int=None):
        pass

    def create_reserved_instances_listing(self, ReservedInstancesId: str, PriceSchedules: List[PriceScheduleSpecification], InstanceCount: int, ClientToken: str) -> CreateReservedInstancesListingResult:
        pass

    def create_route(self, RouteTableId: str, DestinationCidrBlock: str=None, DestinationIpv6CidrBlock: str=None, DryRun: Boolean=None, EgressOnlyInternetGatewayId: str=None, GatewayId: str=None, InstanceId: str=None, NatGatewayId: str=None, TransitGatewayId: str=None, NetworkInterfaceId: str=None, VpcPeeringConnectionId: str=None) -> CreateRouteResult:
        pass

    def create_route_table(self, VpcId: str, DryRun: Boolean=None) -> CreateRouteTableResult:
        pass

    def create_security_group(self, GroupName: str, Description: str, VpcId: str=None, DryRun: Boolean=None) -> CreateSecurityGroupResult:
        pass

    def create_snapshot(self, VolumeId: str, Description: str=None, TagSpecifications: List[TagSpecification]=None, DryRun: Boolean=None) -> Snapshot:
        pass

    def create_spot_datafeed_subscription(self, Bucket: str, DryRun: Boolean=None, Prefix: str=None) -> CreateSpotDatafeedSubscriptionResult:
        pass

    def create_subnet(self, VpcId: str, CidrBlock: str, AvailabilityZone: str=None, AvailabilityZoneId: str=None, Ipv6CidrBlock: str=None, DryRun: Boolean=None) -> CreateSubnetResult:
        pass

    def create_tags(self, Tags: List[Tag], Resources: List[String], DryRun: Boolean=None):
        pass

    def create_transit_gateway(self, Description: str=None, Options: TransitGatewayRequestOptions=None, TagSpecifications: List[TagSpecification]=None, DryRun: Boolean=None) -> CreateTransitGatewayResult:
        pass

    def create_transit_gateway_route(self, TransitGatewayRouteTableId: str, DestinationCidrBlock: str, TransitGatewayAttachmentId: str=None, Blackhole: Boolean=None, DryRun: Boolean=None) -> CreateTransitGatewayRouteResult:
        pass

    def create_transit_gateway_route_table(self, TransitGatewayId: str, TagSpecifications: List[TagSpecification]=None, DryRun: Boolean=None) -> CreateTransitGatewayRouteTableResult:
        pass

    def create_transit_gateway_vpc_attachment(self, SubnetIds: List[String], VpcId: str, TransitGatewayId: str, Options: CreateTransitGatewayVpcAttachmentRequestOptions=None, TagSpecifications: List[TagSpecification]=None, DryRun: Boolean=None) -> CreateTransitGatewayVpcAttachmentResult:
        pass

    def create_volume(self, AvailabilityZone: str, Encrypted: Boolean=None, Iops: int=None, KmsKeyId: str=None, Size: int=None, SnapshotId: str=None, VolumeType: str=None, DryRun: Boolean=None, TagSpecifications: List[TagSpecification]=None) -> Volume:
        pass

    def create_vpc(self, CidrBlock: str, AmazonProvidedIpv6CidrBlock: Boolean=None, DryRun: Boolean=None, InstanceTenancy: str=None) -> CreateVpcResult:
        pass

    def create_vpc_endpoint(self, ServiceName: str, VpcId: str, DryRun: Boolean=None, VpcEndpointType: str=None, PolicyDocument: str=None, RouteTableIds: List[String]=None, SubnetIds: List[String]=None, SecurityGroupIds: List[String]=None, ClientToken: str=None, PrivateDnsEnabled: Boolean=None) -> CreateVpcEndpointResult:
        pass

    def create_vpc_endpoint_connection_notification(self, ConnectionEvents: List[String], ConnectionNotificationArn: str, DryRun: Boolean=None, ServiceId: str=None, VpcEndpointId: str=None, ClientToken: str=None) -> CreateVpcEndpointConnectionNotificationResult:
        pass

    def create_vpc_endpoint_service_configuration(self, NetworkLoadBalancerArns: List[String], DryRun: Boolean=None, AcceptanceRequired: Boolean=None, ClientToken: str=None) -> CreateVpcEndpointServiceConfigurationResult:
        pass

    def create_vpc_peering_connection(self, DryRun: Boolean=None, PeerOwnerId: str=None, PeerVpcId: str=None, VpcId: str=None, PeerRegion: str=None) -> CreateVpcPeeringConnectionResult:
        pass

    def create_vpn_connection(self, Type: str, CustomerGatewayId: str, VpnGatewayId: str=None, TransitGatewayId: str=None, DryRun: Boolean=None, Options: VpnConnectionOptionsSpecification=None) -> CreateVpnConnectionResult:
        pass

    def create_vpn_connection_route(self, VpnConnectionId: str, DestinationCidrBlock: str):
        pass

    def create_vpn_gateway(self, Type: str, AvailabilityZone: str=None, AmazonSideAsn: Long=None, DryRun: Boolean=None) -> CreateVpnGatewayResult:
        pass

    def delete_client_vpn_endpoint(self, ClientVpnEndpointId: str, DryRun: Boolean=None) -> DeleteClientVpnEndpointResult:
        pass

    def delete_client_vpn_route(self, DestinationCidrBlock: str, ClientVpnEndpointId: str, TargetVpcSubnetId: str=None, DryRun: Boolean=None) -> DeleteClientVpnRouteResult:
        pass

    def delete_customer_gateway(self, CustomerGatewayId: str, DryRun: Boolean=None):
        pass

    def delete_dhcp_options(self, DhcpOptionsId: str, DryRun: Boolean=None):
        pass

    def delete_egress_only_internet_gateway(self, EgressOnlyInternetGatewayId: str, DryRun: Boolean=None) -> DeleteEgressOnlyInternetGatewayResult:
        pass

    def delete_fleets(self, TerminateInstances: Boolean, FleetIds: List[FleetIdentifier], DryRun: Boolean=None) -> DeleteFleetsResult:
        pass

    def delete_flow_logs(self, FlowLogIds: List[String], DryRun: Boolean=None) -> DeleteFlowLogsResult:
        pass

    def delete_fpga_image(self, FpgaImageId: str, DryRun: Boolean=None) -> DeleteFpgaImageResult:
        pass

    def delete_internet_gateway(self, InternetGatewayId: str, DryRun: Boolean=None):
        pass

    def delete_key_pair(self, KeyName: str, DryRun: Boolean=None):
        pass

    def delete_launch_template(self, DryRun: Boolean=None, LaunchTemplateId: str=None, LaunchTemplateName: str=None) -> DeleteLaunchTemplateResult:
        pass

    def delete_launch_template_versions(self, Versions: List[String], DryRun: Boolean=None, LaunchTemplateId: str=None, LaunchTemplateName: str=None) -> DeleteLaunchTemplateVersionsResult:
        pass

    def delete_nat_gateway(self, NatGatewayId: str) -> DeleteNatGatewayResult:
        pass

    def delete_network_acl(self, NetworkAclId: str, DryRun: Boolean=None):
        pass

    def delete_network_acl_entry(self, RuleNumber: int, NetworkAclId: str, Egress: Boolean, DryRun: Boolean=None):
        pass

    def delete_network_interface(self, NetworkInterfaceId: str, DryRun: Boolean=None):
        pass

    def delete_network_interface_permission(self, NetworkInterfacePermissionId: str, Force: Boolean=None, DryRun: Boolean=None) -> DeleteNetworkInterfacePermissionResult:
        pass

    def delete_placement_group(self, GroupName: str, DryRun: Boolean=None):
        pass

    def delete_route(self, RouteTableId: str, DestinationCidrBlock: str=None, DestinationIpv6CidrBlock: str=None, DryRun: Boolean=None):
        pass

    def delete_route_table(self, RouteTableId: str, DryRun: Boolean=None):
        pass

    def delete_security_group(self, GroupId: str=None, GroupName: str=None, DryRun: Boolean=None):
        pass

    def delete_snapshot(self, SnapshotId: str, DryRun: Boolean=None):
        pass

    def delete_spot_datafeed_subscription(self, DryRun: Boolean=None):
        pass

    def delete_subnet(self, SubnetId: str, DryRun: Boolean=None):
        pass

    def delete_tags(self, Resources: List[String], DryRun: Boolean=None, Tags: List[Tag]=None):
        pass

    def delete_transit_gateway(self, TransitGatewayId: str, DryRun: Boolean=None) -> DeleteTransitGatewayResult:
        pass

    def delete_transit_gateway_route(self, DestinationCidrBlock: str, TransitGatewayRouteTableId: str, DryRun: Boolean=None) -> DeleteTransitGatewayRouteResult:
        pass

    def delete_transit_gateway_route_table(self, TransitGatewayRouteTableId: str, DryRun: Boolean=None) -> DeleteTransitGatewayRouteTableResult:
        pass

    def delete_transit_gateway_vpc_attachment(self, TransitGatewayAttachmentId: str, DryRun: Boolean=None) -> DeleteTransitGatewayVpcAttachmentResult:
        pass

    def delete_volume(self, VolumeId: str, DryRun: Boolean=None):
        pass

    def delete_vpc(self, VpcId: str, DryRun: Boolean=None):
        pass

    def delete_vpc_endpoint_connection_notifications(self, ConnectionNotificationIds: List[String], DryRun: Boolean=None) -> DeleteVpcEndpointConnectionNotificationsResult:
        pass

    def delete_vpc_endpoint_service_configurations(self, ServiceIds: List[String], DryRun: Boolean=None) -> DeleteVpcEndpointServiceConfigurationsResult:
        pass

    def delete_vpc_endpoints(self, VpcEndpointIds: List[String], DryRun: Boolean=None) -> DeleteVpcEndpointsResult:
        pass

    def delete_vpc_peering_connection(self, VpcPeeringConnectionId: str, DryRun: Boolean=None) -> DeleteVpcPeeringConnectionResult:
        pass

    def delete_vpn_connection(self, VpnConnectionId: str, DryRun: Boolean=None):
        pass

    def delete_vpn_connection_route(self, VpnConnectionId: str, DestinationCidrBlock: str):
        pass

    def delete_vpn_gateway(self, VpnGatewayId: str, DryRun: Boolean=None):
        pass

    def deprovision_byoip_cidr(self, Cidr: str, DryRun: Boolean=None) -> DeprovisionByoipCidrResult:
        pass

    def deregister_image(self, ImageId: str, DryRun: Boolean=None):
        pass

    def describe_account_attributes(self, AttributeNames: List[AccountAttributeName]=None, DryRun: Boolean=None) -> DescribeAccountAttributesResult:
        pass

    def describe_addresses(self, Filters: List[Filter]=None, PublicIps: List[String]=None, AllocationIds: List[String]=None, DryRun: Boolean=None) -> DescribeAddressesResult:
        pass

    def describe_aggregate_id_format(self, DryRun: Boolean=None) -> DescribeAggregateIdFormatResult:
        pass

    def describe_availability_zones(self, Filters: List[Filter]=None, ZoneNames: List[String]=None, ZoneIds: List[String]=None, DryRun: Boolean=None) -> DescribeAvailabilityZonesResult:
        pass

    def describe_bundle_tasks(self, BundleIds: List[String]=None, Filters: List[Filter]=None, DryRun: Boolean=None) -> DescribeBundleTasksResult:
        pass

    def describe_byoip_cidrs(self, MaxResults: int, DryRun: Boolean=None, NextToken: str=None) -> DescribeByoipCidrsResult:
        pass

    def describe_capacity_reservations(self, CapacityReservationIds: List[String]=None, NextToken: str=None, MaxResults: int=None, Filters: List[Filter]=None, DryRun: Boolean=None) -> DescribeCapacityReservationsResult:
        pass

    def describe_classic_link_instances(self, Filters: List[Filter]=None, DryRun: Boolean=None, InstanceIds: List[String]=None, MaxResults: int=None, NextToken: str=None) -> DescribeClassicLinkInstancesResult:
        pass

    def describe_client_vpn_authorization_rules(self, ClientVpnEndpointId: str, DryRun: Boolean=None, NextToken: str=None, Filters: List[Filter]=None, MaxResults: int=None) -> DescribeClientVpnAuthorizationRulesResult:
        pass

    def describe_client_vpn_connections(self, ClientVpnEndpointId: str, Filters: List[Filter]=None, NextToken: str=None, MaxResults: int=None, DryRun: Boolean=None) -> DescribeClientVpnConnectionsResult:
        pass

    def describe_client_vpn_endpoints(self, ClientVpnEndpointIds: List[String]=None, MaxResults: int=None, NextToken: str=None, Filters: List[Filter]=None, DryRun: Boolean=None) -> DescribeClientVpnEndpointsResult:
        pass

    def describe_client_vpn_routes(self, ClientVpnEndpointId: str, Filters: List[Filter]=None, MaxResults: int=None, NextToken: str=None, DryRun: Boolean=None) -> DescribeClientVpnRoutesResult:
        pass

    def describe_client_vpn_target_networks(self, ClientVpnEndpointId: str, AssociationIds: List[String]=None, MaxResults: int=None, NextToken: str=None, Filters: List[Filter]=None, DryRun: Boolean=None) -> DescribeClientVpnTargetNetworksResult:
        pass

    def describe_conversion_tasks(self, ConversionTaskIds: List[String]=None, DryRun: Boolean=None) -> DescribeConversionTasksResult:
        pass

    def describe_customer_gateways(self, CustomerGatewayIds: List[String]=None, Filters: List[Filter]=None, DryRun: Boolean=None) -> DescribeCustomerGatewaysResult:
        pass

    def describe_dhcp_options(self, DhcpOptionsIds: List[String]=None, Filters: List[Filter]=None, DryRun: Boolean=None) -> DescribeDhcpOptionsResult:
        pass

    def describe_egress_only_internet_gateways(self, DryRun: Boolean=None, EgressOnlyInternetGatewayIds: List[EgressOnlyInternetGatewayId]=None, MaxResults: int=None, NextToken: str=None) -> DescribeEgressOnlyInternetGatewaysResult:
        pass

    def describe_elastic_gpus(self, ElasticGpuIds: List[String]=None, DryRun: Boolean=None, Filters: List[Filter]=None, MaxResults: int=None, NextToken: str=None) -> DescribeElasticGpusResult:
        pass

    def describe_export_tasks(self, ExportTaskIds: List[String]=None) -> DescribeExportTasksResult:
        pass

    def describe_fleet_history(self, StartTime: DateTime, FleetId: str, DryRun: Boolean=None, EventType: str=None, MaxResults: int=None, NextToken: str=None) -> DescribeFleetHistoryResult:
        pass

    def describe_fleet_instances(self, FleetId: str, DryRun: Boolean=None, MaxResults: int=None, NextToken: str=None, Filters: List[Filter]=None) -> DescribeFleetInstancesResult:
        pass

    def describe_fleets(self, DryRun: Boolean=None, MaxResults: int=None, NextToken: str=None, FleetIds: List[FleetIdentifier]=None, Filters: List[Filter]=None) -> DescribeFleetsResult:
        pass

    def describe_flow_logs(self, DryRun: Boolean=None, Filter: List[Filter]=None, FlowLogIds: List[String]=None, MaxResults: int=None, NextToken: str=None) -> DescribeFlowLogsResult:
        pass

    def describe_fpga_image_attribute(self, Attribute: str, FpgaImageId: str, DryRun: Boolean=None) -> DescribeFpgaImageAttributeResult:
        pass

    def describe_fpga_images(self, DryRun: Boolean=None, FpgaImageIds: List[String]=None, Owners: List[String]=None, Filters: List[Filter]=None, NextToken: str=None, MaxResults: int=None) -> DescribeFpgaImagesResult:
        pass

    def describe_host_reservation_offerings(self, Filter: List[Filter]=None, MaxDuration: int=None, MaxResults: int=None, MinDuration: int=None, NextToken: str=None, OfferingId: str=None) -> DescribeHostReservationOfferingsResult:
        pass

    def describe_host_reservations(self, Filter: List[Filter]=None, HostReservationIdSet: List[String]=None, MaxResults: int=None, NextToken: str=None) -> DescribeHostReservationsResult:
        pass

    def describe_hosts(self, Filter: List[Filter]=None, HostIds: List[String]=None, MaxResults: int=None, NextToken: str=None) -> DescribeHostsResult:
        pass

    def describe_iam_instance_profile_associations(self, AssociationIds: List[String]=None, Filters: List[Filter]=None, MaxResults: int=None, NextToken: str=None) -> DescribeIamInstanceProfileAssociationsResult:
        pass

    def describe_id_format(self, Resource: str=None) -> DescribeIdFormatResult:
        pass

    def describe_identity_id_format(self, PrincipalArn: str, Resource: str=None) -> DescribeIdentityIdFormatResult:
        pass

    def describe_image_attribute(self, ImageId: str, Attribute: str, DryRun: Boolean=None) -> ImageAttribute:
        pass

    def describe_images(self, ExecutableUsers: List[String]=None, Filters: List[Filter]=None, ImageIds: List[String]=None, Owners: List[String]=None, DryRun: Boolean=None) -> DescribeImagesResult:
        pass

    def describe_import_image_tasks(self, DryRun: Boolean=None, Filters: List[Filter]=None, ImportTaskIds: List[String]=None, MaxResults: int=None, NextToken: str=None) -> DescribeImportImageTasksResult:
        pass

    def describe_import_snapshot_tasks(self, DryRun: Boolean=None, Filters: List[Filter]=None, ImportTaskIds: List[String]=None, MaxResults: int=None, NextToken: str=None) -> DescribeImportSnapshotTasksResult:
        pass

    def describe_instance_attribute(self, InstanceId: str, Attribute: str, DryRun: Boolean=None) -> InstanceAttribute:
        pass

    def describe_instance_credit_specifications(self, DryRun: Boolean=None, Filters: List[Filter]=None, InstanceIds: List[String]=None, MaxResults: int=None, NextToken: str=None) -> DescribeInstanceCreditSpecificationsResult:
        pass

    def describe_instance_status(self, Filters: List[Filter]=None, InstanceIds: List[String]=None, MaxResults: int=None, NextToken: str=None, DryRun: Boolean=None, IncludeAllInstances: Boolean=None) -> DescribeInstanceStatusResult:
        pass

    def describe_instances(self, Filters: List[Filter]=None, InstanceIds: List[String]=None, DryRun: Boolean=None, MaxResults: int=None, NextToken: str=None) -> DescribeInstancesResult:
        pass

    def describe_internet_gateways(self, Filters: List[Filter]=None, DryRun: Boolean=None, InternetGatewayIds: List[String]=None) -> DescribeInternetGatewaysResult:
        pass

    def describe_key_pairs(self, Filters: List[Filter]=None, KeyNames: List[String]=None, DryRun: Boolean=None) -> DescribeKeyPairsResult:
        pass

    def describe_launch_template_versions(self, DryRun: Boolean=None, LaunchTemplateId: str=None, LaunchTemplateName: str=None, Versions: List[String]=None, MinVersion: str=None, MaxVersion: str=None, NextToken: str=None, MaxResults: int=None, Filters: List[Filter]=None) -> DescribeLaunchTemplateVersionsResult:
        pass

    def describe_launch_templates(self, DryRun: Boolean=None, LaunchTemplateIds: List[String]=None, LaunchTemplateNames: List[LaunchTemplateName]=None, Filters: List[Filter]=None, NextToken: str=None, MaxResults: int=None) -> DescribeLaunchTemplatesResult:
        pass

    def describe_moving_addresses(self, Filters: List[Filter]=None, DryRun: Boolean=None, MaxResults: int=None, NextToken: str=None, PublicIps: List[String]=None) -> DescribeMovingAddressesResult:
        pass

    def describe_nat_gateways(self, Filter: List[Filter]=None, MaxResults: int=None, NatGatewayIds: List[String]=None, NextToken: str=None) -> DescribeNatGatewaysResult:
        pass

    def describe_network_acls(self, Filters: List[Filter]=None, DryRun: Boolean=None, NetworkAclIds: List[String]=None) -> DescribeNetworkAclsResult:
        pass

    def describe_network_interface_attribute(self, NetworkInterfaceId: str, Attribute: str=None, DryRun: Boolean=None) -> DescribeNetworkInterfaceAttributeResult:
        pass

    def describe_network_interface_permissions(self, NetworkInterfacePermissionIds: List[String]=None, Filters: List[Filter]=None, NextToken: str=None, MaxResults: int=None) -> DescribeNetworkInterfacePermissionsResult:
        pass

    def describe_network_interfaces(self, Filters: List[Filter]=None, DryRun: Boolean=None, NetworkInterfaceIds: List[String]=None, NextToken: str=None, MaxResults: int=None) -> DescribeNetworkInterfacesResult:
        pass

    def describe_placement_groups(self, Filters: List[Filter]=None, DryRun: Boolean=None, GroupNames: List[String]=None) -> DescribePlacementGroupsResult:
        pass

    def describe_prefix_lists(self, DryRun: Boolean=None, Filters: List[Filter]=None, MaxResults: int=None, NextToken: str=None, PrefixListIds: List[String]=None) -> DescribePrefixListsResult:
        pass

    def describe_principal_id_format(self, DryRun: Boolean=None, Resources: List[String]=None, MaxResults: int=None, NextToken: str=None) -> DescribePrincipalIdFormatResult:
        pass

    def describe_public_ipv_4_pools(self, PoolIds: List[String]=None, NextToken: str=None, MaxResults: int=None) -> DescribePublicIpv4PoolsResult:
        pass

    def describe_regions(self, Filters: List[Filter]=None, RegionNames: List[String]=None, DryRun: Boolean=None) -> DescribeRegionsResult:
        pass

    def describe_reserved_instances(self, Filters: List[Filter]=None, OfferingClass: str=None, ReservedInstancesIds: List[String]=None, DryRun: Boolean=None, OfferingType: str=None) -> DescribeReservedInstancesResult:
        pass

    def describe_reserved_instances_listings(self, Filters: List[Filter]=None, ReservedInstancesId: str=None, ReservedInstancesListingId: str=None) -> DescribeReservedInstancesListingsResult:
        pass

    def describe_reserved_instances_modifications(self, Filters: List[Filter]=None, ReservedInstancesModificationIds: List[String]=None, NextToken: str=None) -> DescribeReservedInstancesModificationsResult:
        pass

    def describe_reserved_instances_offerings(self, AvailabilityZone: str=None, Filters: List[Filter]=None, IncludeMarketplace: Boolean=None, InstanceType: str=None, MaxDuration: Long=None, MaxInstanceCount: int=None, MinDuration: Long=None, OfferingClass: str=None, ProductDescription: str=None, ReservedInstancesOfferingIds: List[String]=None, DryRun: Boolean=None, InstanceTenancy: str=None, MaxResults: int=None, NextToken: str=None, OfferingType: str=None) -> DescribeReservedInstancesOfferingsResult:
        pass

    def describe_route_tables(self, Filters: List[Filter]=None, DryRun: Boolean=None, RouteTableIds: List[String]=None, NextToken: str=None, MaxResults: int=None) -> DescribeRouteTablesResult:
        pass

    def describe_scheduled_instance_availability(self, Recurrence: ScheduledInstanceRecurrenceRequest, FirstSlotStartTimeRange: SlotDateTimeRangeRequest, DryRun: Boolean=None, Filters: List[Filter]=None, MaxResults: int=None, MaxSlotDurationInHours: int=None, MinSlotDurationInHours: int=None, NextToken: str=None) -> DescribeScheduledInstanceAvailabilityResult:
        pass

    def describe_scheduled_instances(self, DryRun: Boolean=None, Filters: List[Filter]=None, MaxResults: int=None, NextToken: str=None, ScheduledInstanceIds: List[String]=None, SlotStartTimeRange: SlotStartTimeRangeRequest=None) -> DescribeScheduledInstancesResult:
        pass

    def describe_security_group_references(self, GroupId: List[String], DryRun: Boolean=None) -> DescribeSecurityGroupReferencesResult:
        pass

    def describe_security_groups(self, Filters: List[Filter]=None, GroupIds: List[String]=None, GroupNames: List[String]=None, DryRun: Boolean=None, NextToken: str=None, MaxResults: int=None) -> DescribeSecurityGroupsResult:
        pass

    def describe_snapshot_attribute(self, SnapshotId: str, Attribute: str, DryRun: Boolean=None) -> DescribeSnapshotAttributeResult:
        pass

    def describe_snapshots(self, Filters: List[Filter]=None, MaxResults: int=None, NextToken: str=None, OwnerIds: List[String]=None, RestorableByUserIds: List[String]=None, SnapshotIds: List[String]=None, DryRun: Boolean=None) -> DescribeSnapshotsResult:
        pass

    def describe_spot_datafeed_subscription(self, DryRun: Boolean=None) -> DescribeSpotDatafeedSubscriptionResult:
        pass

    def describe_spot_fleet_instances(self, SpotFleetRequestId: str, DryRun: Boolean=None, MaxResults: int=None, NextToken: str=None) -> DescribeSpotFleetInstancesResponse:
        pass

    def describe_spot_fleet_request_history(self, StartTime: DateTime, SpotFleetRequestId: str, DryRun: Boolean=None, EventType: str=None, MaxResults: int=None, NextToken: str=None) -> DescribeSpotFleetRequestHistoryResponse:
        pass

    def describe_spot_fleet_requests(self, DryRun: Boolean=None, MaxResults: int=None, NextToken: str=None, SpotFleetRequestIds: List[String]=None) -> DescribeSpotFleetRequestsResponse:
        pass

    def describe_spot_instance_requests(self, Filters: List[Filter]=None, DryRun: Boolean=None, SpotInstanceRequestIds: List[String]=None, NextToken: str=None, MaxResults: int=None) -> DescribeSpotInstanceRequestsResult:
        pass

    def describe_spot_price_history(self, Filters: List[Filter]=None, AvailabilityZone: str=None, DryRun: Boolean=None, EndTime: DateTime=None, InstanceTypes: List[InstanceType]=None, MaxResults: int=None, NextToken: str=None, ProductDescriptions: List[String]=None, StartTime: DateTime=None) -> DescribeSpotPriceHistoryResult:
        pass

    def describe_stale_security_groups(self, VpcId: str, DryRun: Boolean=None, MaxResults: int=None, NextToken: str=None) -> DescribeStaleSecurityGroupsResult:
        pass

    def describe_subnets(self, Filters: List[Filter]=None, SubnetIds: List[String]=None, DryRun: Boolean=None) -> DescribeSubnetsResult:
        pass

    def describe_tags(self, DryRun: Boolean=None, Filters: List[Filter]=None, MaxResults: int=None, NextToken: str=None) -> DescribeTagsResult:
        pass

    def describe_transit_gateway_attachments(self, TransitGatewayAttachmentIds: List[String]=None, Filters: List[Filter]=None, MaxResults: int=None, NextToken: str=None, DryRun: Boolean=None) -> DescribeTransitGatewayAttachmentsResult:
        pass

    def describe_transit_gateway_route_tables(self, TransitGatewayRouteTableIds: List[String]=None, Filters: List[Filter]=None, MaxResults: int=None, NextToken: str=None, DryRun: Boolean=None) -> DescribeTransitGatewayRouteTablesResult:
        pass

    def describe_transit_gateway_vpc_attachments(self, TransitGatewayAttachmentIds: List[String]=None, Filters: List[Filter]=None, MaxResults: int=None, NextToken: str=None, DryRun: Boolean=None) -> DescribeTransitGatewayVpcAttachmentsResult:
        pass

    def describe_transit_gateways(self, TransitGatewayIds: List[String]=None, Filters: List[Filter]=None, MaxResults: int=None, NextToken: str=None, DryRun: Boolean=None) -> DescribeTransitGatewaysResult:
        pass

    def describe_volume_attribute(self, VolumeId: str, Attribute: str, DryRun: Boolean=None) -> DescribeVolumeAttributeResult:
        pass

    def describe_volume_status(self, Filters: List[Filter]=None, MaxResults: int=None, NextToken: str=None, VolumeIds: List[String]=None, DryRun: Boolean=None) -> DescribeVolumeStatusResult:
        pass

    def describe_volumes(self, Filters: List[Filter]=None, VolumeIds: List[String]=None, DryRun: Boolean=None, MaxResults: int=None, NextToken: str=None) -> DescribeVolumesResult:
        pass

    def describe_volumes_modifications(self, DryRun: Boolean=None, VolumeIds: List[String]=None, Filters: List[Filter]=None, NextToken: str=None, MaxResults: int=None) -> DescribeVolumesModificationsResult:
        pass

    def describe_vpc_attribute(self, VpcId: str, Attribute: str, DryRun: Boolean=None) -> DescribeVpcAttributeResult:
        pass

    def describe_vpc_classic_link(self, Filters: List[Filter]=None, DryRun: Boolean=None, VpcIds: List[String]=None) -> DescribeVpcClassicLinkResult:
        pass

    def describe_vpc_classic_link_dns_support(self, MaxResults: int=None, NextToken: str=None, VpcIds: List[String]=None) -> DescribeVpcClassicLinkDnsSupportResult:
        pass

    def describe_vpc_endpoint_connection_notifications(self, DryRun: Boolean=None, ConnectionNotificationId: str=None, Filters: List[Filter]=None, MaxResults: int=None, NextToken: str=None) -> DescribeVpcEndpointConnectionNotificationsResult:
        pass

    def describe_vpc_endpoint_connections(self, DryRun: Boolean=None, Filters: List[Filter]=None, MaxResults: int=None, NextToken: str=None) -> DescribeVpcEndpointConnectionsResult:
        pass

    def describe_vpc_endpoint_service_configurations(self, DryRun: Boolean=None, ServiceIds: List[String]=None, Filters: List[Filter]=None, MaxResults: int=None, NextToken: str=None) -> DescribeVpcEndpointServiceConfigurationsResult:
        pass

    def describe_vpc_endpoint_service_permissions(self, ServiceId: str, DryRun: Boolean=None, Filters: List[Filter]=None, MaxResults: int=None, NextToken: str=None) -> DescribeVpcEndpointServicePermissionsResult:
        pass

    def describe_vpc_endpoint_services(self, DryRun: Boolean=None, ServiceNames: List[String]=None, Filters: List[Filter]=None, MaxResults: int=None, NextToken: str=None) -> DescribeVpcEndpointServicesResult:
        pass

    def describe_vpc_endpoints(self, DryRun: Boolean=None, VpcEndpointIds: List[String]=None, Filters: List[Filter]=None, MaxResults: int=None, NextToken: str=None) -> DescribeVpcEndpointsResult:
        pass

    def describe_vpc_peering_connections(self, Filters: List[Filter]=None, DryRun: Boolean=None, VpcPeeringConnectionIds: List[String]=None, NextToken: str=None, MaxResults: int=None) -> DescribeVpcPeeringConnectionsResult:
        pass

    def describe_vpcs(self, Filters: List[Filter]=None, VpcIds: List[String]=None, DryRun: Boolean=None) -> DescribeVpcsResult:
        pass

    def describe_vpn_connections(self, Filters: List[Filter]=None, VpnConnectionIds: List[String]=None, DryRun: Boolean=None) -> DescribeVpnConnectionsResult:
        pass

    def describe_vpn_gateways(self, Filters: List[Filter]=None, VpnGatewayIds: List[String]=None, DryRun: Boolean=None) -> DescribeVpnGatewaysResult:
        pass

    def detach_classic_link_vpc(self, VpcId: str, InstanceId: str, DryRun: Boolean=None) -> DetachClassicLinkVpcResult:
        pass

    def detach_internet_gateway(self, VpcId: str, InternetGatewayId: str, DryRun: Boolean=None):
        pass

    def detach_network_interface(self, AttachmentId: str, DryRun: Boolean=None, Force: Boolean=None):
        pass

    def detach_volume(self, VolumeId: str, Device: str=None, Force: Boolean=None, InstanceId: str=None, DryRun: Boolean=None) -> VolumeAttachment:
        pass

    def detach_vpn_gateway(self, VpnGatewayId: str, VpcId: str, DryRun: Boolean=None):
        pass

    def disable_transit_gateway_route_table_propagation(self, TransitGatewayAttachmentId: str, TransitGatewayRouteTableId: str, DryRun: Boolean=None) -> DisableTransitGatewayRouteTablePropagationResult:
        pass

    def disable_vgw_route_propagation(self, RouteTableId: str, GatewayId: str):
        pass

    def disable_vpc_classic_link(self, VpcId: str, DryRun: Boolean=None) -> DisableVpcClassicLinkResult:
        pass

    def disable_vpc_classic_link_dns_support(self, VpcId: str=None) -> DisableVpcClassicLinkDnsSupportResult:
        pass

    def disassociate_address(self, AssociationId: str=None, PublicIp: str=None, DryRun: Boolean=None):
        pass

    def disassociate_client_vpn_target_network(self, AssociationId: str, ClientVpnEndpointId: str, DryRun: Boolean=None) -> DisassociateClientVpnTargetNetworkResult:
        pass

    def disassociate_iam_instance_profile(self, AssociationId: str) -> DisassociateIamInstanceProfileResult:
        pass

    def disassociate_route_table(self, AssociationId: str, DryRun: Boolean=None):
        pass

    def disassociate_subnet_cidr_block(self, AssociationId: str) -> DisassociateSubnetCidrBlockResult:
        pass

    def disassociate_transit_gateway_route_table(self, TransitGatewayAttachmentId: str, TransitGatewayRouteTableId: str, DryRun: Boolean=None) -> DisassociateTransitGatewayRouteTableResult:
        pass

    def disassociate_vpc_cidr_block(self, AssociationId: str) -> DisassociateVpcCidrBlockResult:
        pass

    def enable_transit_gateway_route_table_propagation(self, TransitGatewayAttachmentId: str, TransitGatewayRouteTableId: str, DryRun: Boolean=None) -> EnableTransitGatewayRouteTablePropagationResult:
        pass

    def enable_vgw_route_propagation(self, RouteTableId: str, GatewayId: str):
        pass

    def enable_volume_io(self, VolumeId: str, DryRun: Boolean=None):
        pass

    def enable_vpc_classic_link(self, VpcId: str, DryRun: Boolean=None) -> EnableVpcClassicLinkResult:
        pass

    def enable_vpc_classic_link_dns_support(self, VpcId: str=None) -> EnableVpcClassicLinkDnsSupportResult:
        pass

    def export_client_vpn_client_certificate_revocation_list(self, ClientVpnEndpointId: str, DryRun: Boolean=None) -> ExportClientVpnClientCertificateRevocationListResult:
        pass

    def export_client_vpn_client_configuration(self, ClientVpnEndpointId: str, DryRun: Boolean=None) -> ExportClientVpnClientConfigurationResult:
        pass

    def export_transit_gateway_routes(self, S3Bucket: str, TransitGatewayRouteTableId: str, Filters: List[Filter]=None, DryRun: Boolean=None) -> ExportTransitGatewayRoutesResult:
        pass

    def get_console_output(self, InstanceId: str, DryRun: Boolean=None, Latest: Boolean=None) -> GetConsoleOutputResult:
        pass

    def get_console_screenshot(self, InstanceId: str, DryRun: Boolean=None, WakeUp: Boolean=None) -> GetConsoleScreenshotResult:
        pass

    def get_host_reservation_purchase_preview(self, OfferingId: str, HostIdSet: List[String]) -> GetHostReservationPurchasePreviewResult:
        pass

    def get_launch_template_data(self, InstanceId: str, DryRun: Boolean=None) -> GetLaunchTemplateDataResult:
        pass

    def get_password_data(self, InstanceId: str, DryRun: Boolean=None) -> GetPasswordDataResult:
        pass

    def get_reserved_instances_exchange_quote(self, ReservedInstanceIds: List[String], DryRun: Boolean=None, TargetConfigurations: List[TargetConfigurationRequest]=None) -> GetReservedInstancesExchangeQuoteResult:
        pass

    def get_transit_gateway_attachment_propagations(self, TransitGatewayAttachmentId: str, Filters: List[Filter]=None, MaxResults: int=None, NextToken: str=None, DryRun: Boolean=None) -> GetTransitGatewayAttachmentPropagationsResult:
        pass

    def get_transit_gateway_route_table_associations(self, TransitGatewayRouteTableId: str, Filters: List[Filter]=None, MaxResults: int=None, NextToken: str=None, DryRun: Boolean=None) -> GetTransitGatewayRouteTableAssociationsResult:
        pass

    def get_transit_gateway_route_table_propagations(self, TransitGatewayRouteTableId: str, Filters: List[Filter]=None, MaxResults: int=None, NextToken: str=None, DryRun: Boolean=None) -> GetTransitGatewayRouteTablePropagationsResult:
        pass

    def import_client_vpn_client_certificate_revocation_list(self, CertificateRevocationList: str, ClientVpnEndpointId: str, DryRun: Boolean=None) -> ImportClientVpnClientCertificateRevocationListResult:
        pass

    def import_image(self, Architecture: str=None, ClientData: ClientData=None, ClientToken: str=None, Description: str=None, DiskContainers: List[ImageDiskContainer]=None, DryRun: Boolean=None, Encrypted: Boolean=None, Hypervisor: str=None, KmsKeyId: str=None, LicenseType: str=None, Platform: str=None, RoleName: str=None) -> ImportImageResult:
        pass

    def import_instance(self, Platform: str, Description: str=None, DiskImages: List[DiskImage]=None, DryRun: Boolean=None, LaunchSpecification: ImportInstanceLaunchSpecification=None) -> ImportInstanceResult:
        pass

    def import_key_pair(self, PublicKeyMaterial: Blob, KeyName: str, DryRun: Boolean=None) -> ImportKeyPairResult:
        pass

    def import_snapshot(self, ClientData: ClientData=None, ClientToken: str=None, Description: str=None, DiskContainer: SnapshotDiskContainer=None, DryRun: Boolean=None, Encrypted: Boolean=None, KmsKeyId: str=None, RoleName: str=None) -> ImportSnapshotResult:
        pass

    def import_volume(self, Volume: VolumeDetail, Image: DiskImageDetail, AvailabilityZone: str, Description: str=None, DryRun: Boolean=None) -> ImportVolumeResult:
        pass

    def modify_capacity_reservation(self, CapacityReservationId: str, InstanceCount: int=None, EndDate: DateTime=None, EndDateType: str=None, DryRun: Boolean=None) -> ModifyCapacityReservationResult:
        pass

    def modify_client_vpn_endpoint(self, ClientVpnEndpointId: str, ServerCertificateArn: str=None, ConnectionLogOptions: ConnectionLogOptions=None, DnsServers: DnsServersOptionsModifyStructure=None, Description: str=None, DryRun: Boolean=None) -> ModifyClientVpnEndpointResult:
        pass

    def modify_fleet(self, TargetCapacitySpecification: TargetCapacitySpecificationRequest, FleetId: str, DryRun: Boolean=None, ExcessCapacityTerminationPolicy: str=None) -> ModifyFleetResult:
        pass

    def modify_fpga_image_attribute(self, FpgaImageId: str, DryRun: Boolean=None, Attribute: str=None, OperationType: str=None, UserIds: List[String]=None, UserGroups: List[String]=None, ProductCodes: List[String]=None, LoadPermission: LoadPermissionModifications=None, Description: str=None, Name: str=None) -> ModifyFpgaImageAttributeResult:
        pass

    def modify_hosts(self, HostIds: List[String], AutoPlacement: str) -> ModifyHostsResult:
        pass

    def modify_id_format(self, UseLongIds: Boolean, Resource: str):
        pass

    def modify_identity_id_format(self, UseLongIds: Boolean, Resource: str, PrincipalArn: str):
        pass

    def modify_image_attribute(self, ImageId: str, Attribute: str=None, Description: AttributeValue=None, LaunchPermission: LaunchPermissionModifications=None, OperationType: str=None, ProductCodes: List[String]=None, UserGroups: List[String]=None, UserIds: List[String]=None, Value: str=None, DryRun: Boolean=None):
        pass

    def modify_instance_attribute(self, InstanceId: str, SourceDestCheck: AttributeBooleanValue=None, Attribute: str=None, BlockDeviceMappings: List[InstanceBlockDeviceMappingSpecification]=None, DisableApiTermination: AttributeBooleanValue=None, DryRun: Boolean=None, EbsOptimized: AttributeBooleanValue=None, EnaSupport: AttributeBooleanValue=None, Groups: List[String]=None, InstanceInitiatedShutdownBehavior: AttributeValue=None, InstanceType: AttributeValue=None, Kernel: AttributeValue=None, Ramdisk: AttributeValue=None, SriovNetSupport: AttributeValue=None, UserData: BlobAttributeValue=None, Value: str=None):
        pass

    def modify_instance_capacity_reservation_attributes(self, CapacityReservationSpecification: CapacityReservationSpecification, InstanceId: str, DryRun: Boolean=None) -> ModifyInstanceCapacityReservationAttributesResult:
        pass

    def modify_instance_credit_specification(self, InstanceCreditSpecifications: List[InstanceCreditSpecificationRequest], DryRun: Boolean=None, ClientToken: str=None) -> ModifyInstanceCreditSpecificationResult:
        pass

    def modify_instance_placement(self, InstanceId: str, Affinity: str=None, GroupName: str=None, HostId: str=None, Tenancy: str=None, PartitionNumber: int=None) -> ModifyInstancePlacementResult:
        pass

    def modify_launch_template(self, DryRun: Boolean=None, ClientToken: str=None, LaunchTemplateId: str=None, LaunchTemplateName: str=None, DefaultVersion: str=None) -> ModifyLaunchTemplateResult:
        pass

    def modify_network_interface_attribute(self, NetworkInterfaceId: str, Attachment: NetworkInterfaceAttachmentChanges=None, Description: AttributeValue=None, DryRun: Boolean=None, Groups: List[String]=None, SourceDestCheck: AttributeBooleanValue=None):
        pass

    def modify_reserved_instances(self, TargetConfigurations: List[ReservedInstancesConfiguration], ReservedInstancesIds: List[String], ClientToken: str=None) -> ModifyReservedInstancesResult:
        pass

    def modify_snapshot_attribute(self, SnapshotId: str, Attribute: str=None, CreateVolumePermission: CreateVolumePermissionModifications=None, GroupNames: List[String]=None, OperationType: str=None, UserIds: List[String]=None, DryRun: Boolean=None):
        pass

    def modify_spot_fleet_request(self, SpotFleetRequestId: str, ExcessCapacityTerminationPolicy: str=None, TargetCapacity: int=None) -> ModifySpotFleetRequestResponse:
        pass

    def modify_subnet_attribute(self, SubnetId: str, AssignIpv6AddressOnCreation: AttributeBooleanValue=None, MapPublicIpOnLaunch: AttributeBooleanValue=None):
        pass

    def modify_transit_gateway_vpc_attachment(self, TransitGatewayAttachmentId: str, AddSubnetIds: List[String]=None, RemoveSubnetIds: List[String]=None, Options: ModifyTransitGatewayVpcAttachmentRequestOptions=None, DryRun: Boolean=None) -> ModifyTransitGatewayVpcAttachmentResult:
        pass

    def modify_volume(self, VolumeId: str, DryRun: Boolean=None, Size: int=None, VolumeType: str=None, Iops: int=None) -> ModifyVolumeResult:
        pass

    def modify_volume_attribute(self, VolumeId: str, AutoEnableIO: AttributeBooleanValue=None, DryRun: Boolean=None):
        pass

    def modify_vpc_attribute(self, VpcId: str, EnableDnsHostnames: AttributeBooleanValue=None, EnableDnsSupport: AttributeBooleanValue=None):
        pass

    def modify_vpc_endpoint(self, VpcEndpointId: str, DryRun: Boolean=None, ResetPolicy: Boolean=None, PolicyDocument: str=None, AddRouteTableIds: List[String]=None, RemoveRouteTableIds: List[String]=None, AddSubnetIds: List[String]=None, RemoveSubnetIds: List[String]=None, AddSecurityGroupIds: List[String]=None, RemoveSecurityGroupIds: List[String]=None, PrivateDnsEnabled: Boolean=None) -> ModifyVpcEndpointResult:
        pass

    def modify_vpc_endpoint_connection_notification(self, ConnectionNotificationId: str, DryRun: Boolean=None, ConnectionNotificationArn: str=None, ConnectionEvents: List[String]=None) -> ModifyVpcEndpointConnectionNotificationResult:
        pass

    def modify_vpc_endpoint_service_configuration(self, ServiceId: str, DryRun: Boolean=None, AcceptanceRequired: Boolean=None, AddNetworkLoadBalancerArns: List[String]=None, RemoveNetworkLoadBalancerArns: List[String]=None) -> ModifyVpcEndpointServiceConfigurationResult:
        pass

    def modify_vpc_endpoint_service_permissions(self, ServiceId: str, DryRun: Boolean=None, AddAllowedPrincipals: List[String]=None, RemoveAllowedPrincipals: List[String]=None) -> ModifyVpcEndpointServicePermissionsResult:
        pass

    def modify_vpc_peering_connection_options(self, VpcPeeringConnectionId: str, AccepterPeeringConnectionOptions: PeeringConnectionOptionsRequest=None, DryRun: Boolean=None, RequesterPeeringConnectionOptions: PeeringConnectionOptionsRequest=None) -> ModifyVpcPeeringConnectionOptionsResult:
        pass

    def modify_vpc_tenancy(self, InstanceTenancy: str, VpcId: str, DryRun: Boolean=None) -> ModifyVpcTenancyResult:
        pass

    def monitor_instances(self, InstanceIds: List[String], DryRun: Boolean=None) -> MonitorInstancesResult:
        pass

    def move_address_to_vpc(self, PublicIp: str, DryRun: Boolean=None) -> MoveAddressToVpcResult:
        pass

    def provision_byoip_cidr(self, Cidr: str, CidrAuthorizationContext: CidrAuthorizationContext=None, Description: str=None, DryRun: Boolean=None) -> ProvisionByoipCidrResult:
        pass

    def purchase_host_reservation(self, OfferingId: str, HostIdSet: List[String], ClientToken: str=None, CurrencyCode: str=None, LimitPrice: str=None) -> PurchaseHostReservationResult:
        pass

    def purchase_reserved_instances_offering(self, ReservedInstancesOfferingId: str, InstanceCount: int, DryRun: Boolean=None, LimitPrice: ReservedInstanceLimitPrice=None) -> PurchaseReservedInstancesOfferingResult:
        pass

    def purchase_scheduled_instances(self, PurchaseRequests: List[PurchaseRequest], ClientToken: str=None, DryRun: Boolean=None) -> PurchaseScheduledInstancesResult:
        pass

    def reboot_instances(self, InstanceIds: List[String], DryRun: Boolean=None):
        pass

    def register_image(self, Name: str, ImageLocation: str=None, Architecture: str=None, BlockDeviceMappings: List[BlockDeviceMapping]=None, Description: str=None, DryRun: Boolean=None, EnaSupport: Boolean=None, KernelId: str=None, BillingProducts: List[String]=None, RamdiskId: str=None, RootDeviceName: str=None, SriovNetSupport: str=None, VirtualizationType: str=None) -> RegisterImageResult:
        pass

    def reject_transit_gateway_vpc_attachment(self, TransitGatewayAttachmentId: str, DryRun: Boolean=None) -> RejectTransitGatewayVpcAttachmentResult:
        pass

    def reject_vpc_endpoint_connections(self, VpcEndpointIds: List[String], ServiceId: str, DryRun: Boolean=None) -> RejectVpcEndpointConnectionsResult:
        pass

    def reject_vpc_peering_connection(self, VpcPeeringConnectionId: str, DryRun: Boolean=None) -> RejectVpcPeeringConnectionResult:
        pass

    def release_address(self, AllocationId: str=None, PublicIp: str=None, DryRun: Boolean=None):
        pass

    def release_hosts(self, HostIds: List[String]) -> ReleaseHostsResult:
        pass

    def replace_iam_instance_profile_association(self, AssociationId: str, IamInstanceProfile: IamInstanceProfileSpecification) -> ReplaceIamInstanceProfileAssociationResult:
        pass

    def replace_network_acl_association(self, NetworkAclId: str, AssociationId: str, DryRun: Boolean=None) -> ReplaceNetworkAclAssociationResult:
        pass

    def replace_network_acl_entry(self, RuleNumber: int, RuleAction: str, Protocol: str, NetworkAclId: str, Egress: Boolean, CidrBlock: str=None, DryRun: Boolean=None, IcmpTypeCode: IcmpTypeCode=None, Ipv6CidrBlock: str=None, PortRange: PortRange=None):
        pass

    def replace_route(self, RouteTableId: str, DestinationCidrBlock: str=None, DestinationIpv6CidrBlock: str=None, DryRun: Boolean=None, EgressOnlyInternetGatewayId: str=None, GatewayId: str=None, InstanceId: str=None, NatGatewayId: str=None, TransitGatewayId: str=None, NetworkInterfaceId: str=None, VpcPeeringConnectionId: str=None):
        pass

    def replace_route_table_association(self, RouteTableId: str, AssociationId: str, DryRun: Boolean=None) -> ReplaceRouteTableAssociationResult:
        pass

    def replace_transit_gateway_route(self, TransitGatewayRouteTableId: str, DestinationCidrBlock: str, TransitGatewayAttachmentId: str=None, Blackhole: Boolean=None, DryRun: Boolean=None) -> ReplaceTransitGatewayRouteResult:
        pass

    def report_instance_status(self, Status: str, ReasonCodes: List[ReportInstanceReasonCodes], Instances: List[String], Description: str=None, DryRun: Boolean=None, EndTime: DateTime=None, StartTime: DateTime=None):
        pass

    def request_spot_fleet(self, SpotFleetRequestConfig: SpotFleetRequestConfigData, DryRun: Boolean=None) -> RequestSpotFleetResponse:
        pass

    def request_spot_instances(self, AvailabilityZoneGroup: str=None, BlockDurationMinutes: int=None, ClientToken: str=None, DryRun: Boolean=None, InstanceCount: int=None, LaunchGroup: str=None, LaunchSpecification: RequestSpotLaunchSpecification=None, SpotPrice: str=None, Type: str=None, ValidFrom: DateTime=None, ValidUntil: DateTime=None, InstanceInterruptionBehavior: str=None) -> RequestSpotInstancesResult:
        pass

    def reset_fpga_image_attribute(self, FpgaImageId: str, DryRun: Boolean=None, Attribute: str=None) -> ResetFpgaImageAttributeResult:
        pass

    def reset_image_attribute(self, ImageId: str, Attribute: str, DryRun: Boolean=None):
        pass

    def reset_instance_attribute(self, InstanceId: str, Attribute: str, DryRun: Boolean=None):
        pass

    def reset_network_interface_attribute(self, NetworkInterfaceId: str, DryRun: Boolean=None, SourceDestCheck: str=None):
        pass

    def reset_snapshot_attribute(self, SnapshotId: str, Attribute: str, DryRun: Boolean=None):
        pass

    def restore_address_to_classic(self, PublicIp: str, DryRun: Boolean=None) -> RestoreAddressToClassicResult:
        pass

    def revoke_client_vpn_ingress(self, TargetNetworkCidr: str, ClientVpnEndpointId: str, AccessGroupId: str=None, RevokeAllGroups: Boolean=None, DryRun: Boolean=None) -> RevokeClientVpnIngressResult:
        pass

    def revoke_security_group_egress(self, GroupId: str, DryRun: Boolean=None, IpPermissions: List[IpPermission]=None, CidrIp: str=None, FromPort: int=None, IpProtocol: str=None, ToPort: int=None, SourceSecurityGroupName: str=None, SourceSecurityGroupOwnerId: str=None):
        pass

    def revoke_security_group_ingress(self, CidrIp: str=None, FromPort: int=None, GroupId: str=None, GroupName: str=None, IpPermissions: List[IpPermission]=None, IpProtocol: str=None, SourceSecurityGroupName: str=None, SourceSecurityGroupOwnerId: str=None, ToPort: int=None, DryRun: Boolean=None):
        pass

    def run_instances(self, MinCount: int, MaxCount: int, BlockDeviceMappings: List[BlockDeviceMapping]=None, ImageId: str=None, InstanceType: str=None, Ipv6AddressCount: int=None, Ipv6Addresses: List[InstanceIpv6Address]=None, KernelId: str=None, KeyName: str=None, Monitoring: RunInstancesMonitoringEnabled=None, Placement: Placement=None, RamdiskId: str=None, SecurityGroupIds: List[String]=None, SecurityGroups: List[String]=None, SubnetId: str=None, UserData: str=None, AdditionalInfo: str=None, ClientToken: str=None, DisableApiTermination: Boolean=None, DryRun: Boolean=None, EbsOptimized: Boolean=None, IamInstanceProfile: IamInstanceProfileSpecification=None, InstanceInitiatedShutdownBehavior: str=None, NetworkInterfaces: List[InstanceNetworkInterfaceSpecification]=None, PrivateIpAddress: str=None, ElasticGpuSpecification: List[ElasticGpuSpecification]=None, ElasticInferenceAccelerators: List[ElasticInferenceAccelerator]=None, TagSpecifications: List[TagSpecification]=None, LaunchTemplate: LaunchTemplateSpecification=None, InstanceMarketOptions: InstanceMarketOptionsRequest=None, CreditSpecification: CreditSpecificationRequest=None, CpuOptions: CpuOptionsRequest=None, CapacityReservationSpecification: CapacityReservationSpecification=None, HibernationOptions: HibernationOptionsRequest=None, LicenseSpecifications: List[LicenseConfigurationRequest]=None) -> Reservation:
        pass

    def run_scheduled_instances(self, ScheduledInstanceId: str, LaunchSpecification: ScheduledInstancesLaunchSpecification, ClientToken: str=None, DryRun: Boolean=None, InstanceCount: int=None) -> RunScheduledInstancesResult:
        pass

    def search_transit_gateway_routes(self, Filters: List[Filter], TransitGatewayRouteTableId: str, MaxResults: int=None, DryRun: Boolean=None) -> SearchTransitGatewayRoutesResult:
        pass

    def start_instances(self, InstanceIds: List[String], AdditionalInfo: str=None, DryRun: Boolean=None) -> StartInstancesResult:
        pass

    def stop_instances(self, InstanceIds: List[String], Hibernate: Boolean=None, DryRun: Boolean=None, Force: Boolean=None) -> StopInstancesResult:
        pass

    def terminate_client_vpn_connections(self, ClientVpnEndpointId: str, ConnectionId: str=None, Username: str=None, DryRun: Boolean=None) -> TerminateClientVpnConnectionsResult:
        pass

    def terminate_instances(self, InstanceIds: List[String], DryRun: Boolean=None) -> TerminateInstancesResult:
        pass

    def unassign_ipv6_addresses(self, NetworkInterfaceId: str, Ipv6Addresses: List[String]) -> UnassignIpv6AddressesResult:
        pass

    def unassign_private_ip_addresses(self, PrivateIpAddresses: List[String], NetworkInterfaceId: str):
        pass

    def unmonitor_instances(self, InstanceIds: List[String], DryRun: Boolean=None) -> UnmonitorInstancesResult:
        pass

    def update_security_group_rule_descriptions_egress(self, IpPermissions: List[IpPermission], DryRun: Boolean=None, GroupId: str=None, GroupName: str=None) -> UpdateSecurityGroupRuleDescriptionsEgressResult:
        pass

    def update_security_group_rule_descriptions_ingress(self, IpPermissions: List[IpPermission], DryRun: Boolean=None, GroupId: str=None, GroupName: str=None) -> UpdateSecurityGroupRuleDescriptionsIngressResult:
        pass

    def withdraw_byoip_cidr(self, Cidr: str, DryRun: Boolean=None) -> WithdrawByoipCidrResult:
        pass


class ECR(BaseClient):
    class BatchCheckLayerAvailabilityRequest(Mapping):
        pass

    class BatchCheckLayerAvailabilityResponse(Mapping):
        pass

    class BatchedOperationLayerDigest(object):
        pass

    class BatchDeleteImageRequest(Mapping):
        pass

    class BatchDeleteImageResponse(Mapping):
        pass

    class ImageIdentifier(Mapping):
        pass

    class BatchGetImageRequest(Mapping):
        pass

    class BatchGetImageResponse(Mapping):
        pass

    class MediaType(object):
        pass

    class CompleteLayerUploadRequest(Mapping):
        pass

    class CompleteLayerUploadResponse(Mapping):
        pass

    class LayerDigest(object):
        pass

    class CreateRepositoryRequest(Mapping):
        pass

    class CreateRepositoryResponse(Mapping):
        pass

    class Tag(Mapping):
        pass

    class DeleteLifecyclePolicyRequest(Mapping):
        pass

    class DeleteLifecyclePolicyResponse(Mapping):
        pass

    class DeleteRepositoryRequest(Mapping):
        pass

    class DeleteRepositoryResponse(Mapping):
        pass

    class ForceFlag(object):
        pass

    class DeleteRepositoryPolicyRequest(Mapping):
        pass

    class DeleteRepositoryPolicyResponse(Mapping):
        pass

    class DescribeImagesRequest(Mapping):
        pass

    class DescribeImagesResponse(Mapping):
        pass

    class DescribeImagesFilter(Mapping):
        pass

    class DescribeRepositoriesRequest(Mapping):
        pass

    class DescribeRepositoriesResponse(Mapping):
        pass

    class RepositoryName(object):
        pass

    class GetAuthorizationTokenRequest(Mapping):
        pass

    class GetAuthorizationTokenResponse(Mapping):
        pass

    class RegistryId(object):
        pass

    class GetDownloadUrlForLayerRequest(Mapping):
        pass

    class GetDownloadUrlForLayerResponse(Mapping):
        pass

    class GetLifecyclePolicyRequest(Mapping):
        pass

    class GetLifecyclePolicyResponse(Mapping):
        pass

    class GetLifecyclePolicyPreviewRequest(Mapping):
        pass

    class GetLifecyclePolicyPreviewResponse(Mapping):
        pass

    class LifecyclePolicyPreviewFilter(Mapping):
        pass

    class GetRepositoryPolicyRequest(Mapping):
        pass

    class GetRepositoryPolicyResponse(Mapping):
        pass

    class InitiateLayerUploadRequest(Mapping):
        pass

    class InitiateLayerUploadResponse(Mapping):
        pass

    class ListImagesRequest(Mapping):
        pass

    class ListImagesResponse(Mapping):
        pass

    class ListImagesFilter(Mapping):
        pass

    class ListTagsForResourceRequest(Mapping):
        pass

    class ListTagsForResourceResponse(Mapping):
        pass

    class PutImageRequest(Mapping):
        pass

    class PutImageResponse(Mapping):
        pass

    class PutLifecyclePolicyRequest(Mapping):
        pass

    class PutLifecyclePolicyResponse(Mapping):
        pass

    class SetRepositoryPolicyRequest(Mapping):
        pass

    class SetRepositoryPolicyResponse(Mapping):
        pass

    class StartLifecyclePolicyPreviewRequest(Mapping):
        pass

    class StartLifecyclePolicyPreviewResponse(Mapping):
        pass

    class TagResourceRequest(Mapping):
        pass

    class TagResourceResponse(Mapping):
        pass

    class UntagResourceRequest(Mapping):
        pass

    class UntagResourceResponse(Mapping):
        pass

    class TagKey(object):
        pass

    class UploadLayerPartRequest(Mapping):
        pass

    class UploadLayerPartResponse(Mapping):
        pass

    class PartSize(object):
        pass

    class LayerPartBlob(object):
        pass

    def batch_check_layer_availability(self, layerDigests: List[BatchedOperationLayerDigest], repositoryName: str, registryId: str=None) -> BatchCheckLayerAvailabilityResponse:
        pass

    def batch_delete_image(self, imageIds: List[ImageIdentifier], repositoryName: str, registryId: str=None) -> BatchDeleteImageResponse:
        pass

    def batch_get_image(self, imageIds: List[ImageIdentifier], repositoryName: str, registryId: str=None, acceptedMediaTypes: List[MediaType]=None) -> BatchGetImageResponse:
        pass

    def complete_layer_upload(self, layerDigests: List[LayerDigest], uploadId: str, repositoryName: str, registryId: str=None) -> CompleteLayerUploadResponse:
        pass

    def create_repository(self, repositoryName: str, tags: List[Tag]=None) -> CreateRepositoryResponse:
        pass

    def delete_lifecycle_policy(self, repositoryName: str, registryId: str=None) -> DeleteLifecyclePolicyResponse:
        pass

    def delete_repository(self, repositoryName: str, registryId: str=None, force: ForceFlag=None) -> DeleteRepositoryResponse:
        pass

    def delete_repository_policy(self, repositoryName: str, registryId: str=None) -> DeleteRepositoryPolicyResponse:
        pass

    def describe_images(self, repositoryName: str, registryId: str=None, imageIds: List[ImageIdentifier]=None, nextToken: str=None, maxResults: int=None, filter: DescribeImagesFilter=None) -> DescribeImagesResponse:
        pass

    def describe_repositories(self, registryId: str=None, repositoryNames: List[RepositoryName]=None, nextToken: str=None, maxResults: int=None) -> DescribeRepositoriesResponse:
        pass

    def get_authorization_token(self, registryIds: List[RegistryId]=None) -> GetAuthorizationTokenResponse:
        pass

    def get_download_url_for_layer(self, layerDigest: str, repositoryName: str, registryId: str=None) -> GetDownloadUrlForLayerResponse:
        pass

    def get_lifecycle_policy(self, repositoryName: str, registryId: str=None) -> GetLifecyclePolicyResponse:
        pass

    def get_lifecycle_policy_preview(self, repositoryName: str, registryId: str=None, imageIds: List[ImageIdentifier]=None, nextToken: str=None, maxResults: int=None, filter: LifecyclePolicyPreviewFilter=None) -> GetLifecyclePolicyPreviewResponse:
        pass

    def get_repository_policy(self, repositoryName: str, registryId: str=None) -> GetRepositoryPolicyResponse:
        pass

    def initiate_layer_upload(self, repositoryName: str, registryId: str=None) -> InitiateLayerUploadResponse:
        pass

    def list_images(self, repositoryName: str, registryId: str=None, nextToken: str=None, maxResults: int=None, filter: ListImagesFilter=None) -> ListImagesResponse:
        pass

    def list_tags_for_resource(self, resourceArn: str) -> ListTagsForResourceResponse:
        pass

    def put_image(self, imageManifest: str, repositoryName: str, registryId: str=None, imageTag: str=None) -> PutImageResponse:
        pass

    def put_lifecycle_policy(self, lifecyclePolicyText: str, repositoryName: str, registryId: str=None) -> PutLifecyclePolicyResponse:
        pass

    def set_repository_policy(self, policyText: str, repositoryName: str, registryId: str=None, force: ForceFlag=None) -> SetRepositoryPolicyResponse:
        pass

    def start_lifecycle_policy_preview(self, repositoryName: str, registryId: str=None, lifecyclePolicyText: str=None) -> StartLifecyclePolicyPreviewResponse:
        pass

    def tag_resource(self, tags: List[Tag], resourceArn: str) -> TagResourceResponse:
        pass

    def untag_resource(self, tagKeys: List[TagKey], resourceArn: str) -> UntagResourceResponse:
        pass

    def upload_layer_part(self, layerPartBlob: LayerPartBlob, partLastByte: PartSize, partFirstByte: PartSize, uploadId: str, repositoryName: str, registryId: str=None) -> UploadLayerPartResponse:
        pass


class ECS(BaseClient):
    class CreateClusterRequest(Mapping):
        pass

    class CreateClusterResponse(Mapping):
        pass

    class Tag(Mapping):
        pass

    class CreateServiceRequest(Mapping):
        pass

    class CreateServiceResponse(Mapping):
        pass

    class LoadBalancer(Mapping):
        pass

    class ServiceRegistry(Mapping):
        pass

    class DeploymentConfiguration(Mapping):
        pass

    class PlacementConstraint(Mapping):
        pass

    class PlacementStrategy(Mapping):
        pass

    class NetworkConfiguration(Mapping):
        pass

    class DeploymentController(Mapping):
        pass

    class Boolean(object):
        pass

    class DeleteAccountSettingRequest(Mapping):
        pass

    class DeleteAccountSettingResponse(Mapping):
        pass

    class DeleteAttributesRequest(Mapping):
        pass

    class DeleteAttributesResponse(Mapping):
        pass

    class Attribute(Mapping):
        pass

    class DeleteClusterRequest(Mapping):
        pass

    class DeleteClusterResponse(Mapping):
        pass

    class DeleteServiceRequest(Mapping):
        pass

    class DeleteServiceResponse(Mapping):
        pass

    class BoxedBoolean(object):
        pass

    class DeregisterContainerInstanceRequest(Mapping):
        pass

    class DeregisterContainerInstanceResponse(Mapping):
        pass

    class DeregisterTaskDefinitionRequest(Mapping):
        pass

    class DeregisterTaskDefinitionResponse(Mapping):
        pass

    class DescribeClustersRequest(Mapping):
        pass

    class DescribeClustersResponse(Mapping):
        pass

    class String(object):
        pass

    class ClusterField(object):
        pass

    class DescribeContainerInstancesRequest(Mapping):
        pass

    class DescribeContainerInstancesResponse(Mapping):
        pass

    class ContainerInstanceField(object):
        pass

    class DescribeServicesRequest(Mapping):
        pass

    class DescribeServicesResponse(Mapping):
        pass

    class ServiceField(object):
        pass

    class DescribeTaskDefinitionRequest(Mapping):
        pass

    class DescribeTaskDefinitionResponse(Mapping):
        pass

    class TaskDefinitionField(object):
        pass

    class DescribeTasksRequest(Mapping):
        pass

    class DescribeTasksResponse(Mapping):
        pass

    class TaskField(object):
        pass

    class DiscoverPollEndpointRequest(Mapping):
        pass

    class DiscoverPollEndpointResponse(Mapping):
        pass

    class ListAccountSettingsRequest(Mapping):
        pass

    class ListAccountSettingsResponse(Mapping):
        pass

    class ListAttributesRequest(Mapping):
        pass

    class ListAttributesResponse(Mapping):
        pass

    class ListClustersRequest(Mapping):
        pass

    class ListClustersResponse(Mapping):
        pass

    class ListContainerInstancesRequest(Mapping):
        pass

    class ListContainerInstancesResponse(Mapping):
        pass

    class ListServicesRequest(Mapping):
        pass

    class ListServicesResponse(Mapping):
        pass

    class ListTagsForResourceRequest(Mapping):
        pass

    class ListTagsForResourceResponse(Mapping):
        pass

    class ListTaskDefinitionFamiliesRequest(Mapping):
        pass

    class ListTaskDefinitionFamiliesResponse(Mapping):
        pass

    class ListTaskDefinitionsRequest(Mapping):
        pass

    class ListTaskDefinitionsResponse(Mapping):
        pass

    class ListTasksRequest(Mapping):
        pass

    class ListTasksResponse(Mapping):
        pass

    class PutAccountSettingRequest(Mapping):
        pass

    class PutAccountSettingResponse(Mapping):
        pass

    class PutAttributesRequest(Mapping):
        pass

    class PutAttributesResponse(Mapping):
        pass

    class RegisterContainerInstanceRequest(Mapping):
        pass

    class RegisterContainerInstanceResponse(Mapping):
        pass

    class Resource(Mapping):
        pass

    class VersionInfo(Mapping):
        pass

    class PlatformDevice(Mapping):
        pass

    class RegisterTaskDefinitionRequest(Mapping):
        pass

    class RegisterTaskDefinitionResponse(Mapping):
        pass

    class ContainerDefinition(Mapping):
        pass

    class Volume(Mapping):
        pass

    class TaskDefinitionPlacementConstraint(Mapping):
        pass

    class Compatibility(object):
        pass

    class RunTaskRequest(Mapping):
        pass

    class RunTaskResponse(Mapping):
        pass

    class TaskOverride(Mapping):
        pass

    class StartTaskRequest(Mapping):
        pass

    class StartTaskResponse(Mapping):
        pass

    class StopTaskRequest(Mapping):
        pass

    class StopTaskResponse(Mapping):
        pass

    class SubmitContainerStateChangeRequest(Mapping):
        pass

    class SubmitContainerStateChangeResponse(Mapping):
        pass

    class NetworkBinding(Mapping):
        pass

    class SubmitTaskStateChangeRequest(Mapping):
        pass

    class SubmitTaskStateChangeResponse(Mapping):
        pass

    class ContainerStateChange(Mapping):
        pass

    class AttachmentStateChange(Mapping):
        pass

    class Timestamp(object):
        pass

    class TagResourceRequest(Mapping):
        pass

    class TagResourceResponse(Mapping):
        pass

    class UntagResourceRequest(Mapping):
        pass

    class UntagResourceResponse(Mapping):
        pass

    class TagKey(object):
        pass

    class UpdateContainerAgentRequest(Mapping):
        pass

    class UpdateContainerAgentResponse(Mapping):
        pass

    class UpdateContainerInstancesStateRequest(Mapping):
        pass

    class UpdateContainerInstancesStateResponse(Mapping):
        pass

    class UpdateServiceRequest(Mapping):
        pass

    class UpdateServiceResponse(Mapping):
        pass

    def create_cluster(self, clusterName: str=None, tags: List[Tag]=None) -> CreateClusterResponse:
        pass

    def create_service(self, taskDefinition: str, serviceName: str, cluster: str=None, loadBalancers: List[LoadBalancer]=None, serviceRegistries: List[ServiceRegistry]=None, desiredCount: int=None, clientToken: str=None, launchType: str=None, platformVersion: str=None, role: str=None, deploymentConfiguration: DeploymentConfiguration=None, placementConstraints: List[PlacementConstraint]=None, placementStrategy: List[PlacementStrategy]=None, networkConfiguration: NetworkConfiguration=None, healthCheckGracePeriodSeconds: int=None, schedulingStrategy: str=None, deploymentController: DeploymentController=None, tags: List[Tag]=None, enableECSManagedTags: Boolean=None, propagateTags: str=None) -> CreateServiceResponse:
        pass

    def delete_account_setting(self, name: str, principalArn: str=None) -> DeleteAccountSettingResponse:
        pass

    def delete_attributes(self, attributes: List[Attribute], cluster: str=None) -> DeleteAttributesResponse:
        pass

    def delete_cluster(self, cluster: str) -> DeleteClusterResponse:
        pass

    def delete_service(self, service: str, cluster: str=None, force: BoxedBoolean=None) -> DeleteServiceResponse:
        pass

    def deregister_container_instance(self, containerInstance: str, cluster: str=None, force: BoxedBoolean=None) -> DeregisterContainerInstanceResponse:
        pass

    def deregister_task_definition(self, taskDefinition: str) -> DeregisterTaskDefinitionResponse:
        pass

    def describe_clusters(self, clusters: List[String]=None, include: List[ClusterField]=None) -> DescribeClustersResponse:
        pass

    def describe_container_instances(self, containerInstances: List[String], cluster: str=None, include: List[ContainerInstanceField]=None) -> DescribeContainerInstancesResponse:
        pass

    def describe_services(self, services: List[String], cluster: str=None, include: List[ServiceField]=None) -> DescribeServicesResponse:
        pass

    def describe_task_definition(self, taskDefinition: str, include: List[TaskDefinitionField]=None) -> DescribeTaskDefinitionResponse:
        pass

    def describe_tasks(self, tasks: List[String], cluster: str=None, include: List[TaskField]=None) -> DescribeTasksResponse:
        pass

    def discover_poll_endpoint(self, containerInstance: str=None, cluster: str=None) -> DiscoverPollEndpointResponse:
        pass

    def list_account_settings(self, name: str=None, value: str=None, principalArn: str=None, effectiveSettings: Boolean=None, nextToken: str=None, maxResults: int=None) -> ListAccountSettingsResponse:
        pass

    def list_attributes(self, targetType: str, cluster: str=None, attributeName: str=None, attributeValue: str=None, nextToken: str=None, maxResults: int=None) -> ListAttributesResponse:
        pass

    def list_clusters(self, nextToken: str=None, maxResults: int=None) -> ListClustersResponse:
        pass

    def list_container_instances(self, cluster: str=None, filter: str=None, nextToken: str=None, maxResults: int=None, status: str=None) -> ListContainerInstancesResponse:
        pass

    def list_services(self, cluster: str=None, nextToken: str=None, maxResults: int=None, launchType: str=None, schedulingStrategy: str=None) -> ListServicesResponse:
        pass

    def list_tags_for_resource(self, resourceArn: str) -> ListTagsForResourceResponse:
        pass

    def list_task_definition_families(self, familyPrefix: str=None, status: str=None, nextToken: str=None, maxResults: int=None) -> ListTaskDefinitionFamiliesResponse:
        pass

    def list_task_definitions(self, familyPrefix: str=None, status: str=None, sort: str=None, nextToken: str=None, maxResults: int=None) -> ListTaskDefinitionsResponse:
        pass

    def list_tasks(self, cluster: str=None, containerInstance: str=None, family: str=None, nextToken: str=None, maxResults: int=None, startedBy: str=None, serviceName: str=None, desiredStatus: str=None, launchType: str=None) -> ListTasksResponse:
        pass

    def put_account_setting(self, value: str, name: str, principalArn: str=None) -> PutAccountSettingResponse:
        pass

    def put_attributes(self, attributes: List[Attribute], cluster: str=None) -> PutAttributesResponse:
        pass

    def register_container_instance(self, cluster: str=None, instanceIdentityDocument: str=None, instanceIdentityDocumentSignature: str=None, totalResources: List[Resource]=None, versionInfo: VersionInfo=None, containerInstanceArn: str=None, attributes: List[Attribute]=None, platformDevices: List[PlatformDevice]=None, tags: List[Tag]=None) -> RegisterContainerInstanceResponse:
        pass

    def register_task_definition(self, containerDefinitions: List[ContainerDefinition], family: str, taskRoleArn: str=None, executionRoleArn: str=None, networkMode: str=None, volumes: List[Volume]=None, placementConstraints: List[TaskDefinitionPlacementConstraint]=None, requiresCompatibilities: List[Compatibility]=None, cpu: str=None, memory: str=None, tags: List[Tag]=None, pidMode: str=None, ipcMode: str=None) -> RegisterTaskDefinitionResponse:
        pass

    def run_task(self, taskDefinition: str, cluster: str=None, overrides: TaskOverride=None, count: int=None, startedBy: str=None, group: str=None, placementConstraints: List[PlacementConstraint]=None, placementStrategy: List[PlacementStrategy]=None, launchType: str=None, platformVersion: str=None, networkConfiguration: NetworkConfiguration=None, tags: List[Tag]=None, enableECSManagedTags: Boolean=None, propagateTags: str=None) -> RunTaskResponse:
        pass

    def start_task(self, containerInstances: List[String], taskDefinition: str, cluster: str=None, overrides: TaskOverride=None, startedBy: str=None, group: str=None, networkConfiguration: NetworkConfiguration=None, tags: List[Tag]=None, enableECSManagedTags: Boolean=None, propagateTags: str=None) -> StartTaskResponse:
        pass

    def stop_task(self, task: str, cluster: str=None, reason: str=None) -> StopTaskResponse:
        pass

    def submit_container_state_change(self, cluster: str=None, task: str=None, containerName: str=None, status: str=None, exitCode: int=None, reason: str=None, networkBindings: List[NetworkBinding]=None) -> SubmitContainerStateChangeResponse:
        pass

    def submit_task_state_change(self, cluster: str=None, task: str=None, status: str=None, reason: str=None, containers: List[ContainerStateChange]=None, attachments: List[AttachmentStateChange]=None, pullStartedAt: Timestamp=None, pullStoppedAt: Timestamp=None, executionStoppedAt: Timestamp=None) -> SubmitTaskStateChangeResponse:
        pass

    def tag_resource(self, tags: List[Tag], resourceArn: str) -> TagResourceResponse:
        pass

    def untag_resource(self, tagKeys: List[TagKey], resourceArn: str) -> UntagResourceResponse:
        pass

    def update_container_agent(self, containerInstance: str, cluster: str=None) -> UpdateContainerAgentResponse:
        pass

    def update_container_instances_state(self, status: str, containerInstances: List[String], cluster: str=None) -> UpdateContainerInstancesStateResponse:
        pass

    def update_service(self, service: str, cluster: str=None, desiredCount: int=None, taskDefinition: str=None, deploymentConfiguration: DeploymentConfiguration=None, networkConfiguration: NetworkConfiguration=None, platformVersion: str=None, forceNewDeployment: Boolean=None, healthCheckGracePeriodSeconds: int=None) -> UpdateServiceResponse:
        pass


class EFS(BaseClient):
    class CreateFileSystemRequest(Mapping):
        pass

    class FileSystemDescription(Mapping):
        pass

    class Encrypted(object):
        pass

    class ProvisionedThroughputInMibps(object):
        pass

    class CreateMountTargetRequest(Mapping):
        pass

    class MountTargetDescription(Mapping):
        pass

    class SecurityGroup(object):
        pass

    class CreateTagsRequest(Mapping):
        pass

    class Tag(Mapping):
        pass

    class DeleteFileSystemRequest(Mapping):
        pass

    class DeleteMountTargetRequest(Mapping):
        pass

    class DeleteTagsRequest(Mapping):
        pass

    class TagKey(object):
        pass

    class DescribeFileSystemsRequest(Mapping):
        pass

    class DescribeFileSystemsResponse(Mapping):
        pass

    class DescribeMountTargetSecurityGroupsRequest(Mapping):
        pass

    class DescribeMountTargetSecurityGroupsResponse(Mapping):
        pass

    class DescribeMountTargetsRequest(Mapping):
        pass

    class DescribeMountTargetsResponse(Mapping):
        pass

    class DescribeTagsRequest(Mapping):
        pass

    class DescribeTagsResponse(Mapping):
        pass

    class ModifyMountTargetSecurityGroupsRequest(Mapping):
        pass

    class UpdateFileSystemRequest(Mapping):
        pass

    def create_file_system(self, CreationToken: str, PerformanceMode: str=None, Encrypted: Encrypted=None, KmsKeyId: str=None, ThroughputMode: str=None, ProvisionedThroughputInMibps: ProvisionedThroughputInMibps=None) -> FileSystemDescription:
        pass

    def create_mount_target(self, SubnetId: str, FileSystemId: str, IpAddress: str=None, SecurityGroups: List[SecurityGroup]=None) -> MountTargetDescription:
        pass

    def create_tags(self, Tags: List[Tag], FileSystemId: str):
        pass

    def delete_file_system(self, FileSystemId: str):
        pass

    def delete_mount_target(self, MountTargetId: str):
        pass

    def delete_tags(self, TagKeys: List[TagKey], FileSystemId: str):
        pass

    def describe_file_systems(self, MaxItems: int=None, Marker: str=None, CreationToken: str=None, FileSystemId: str=None) -> DescribeFileSystemsResponse:
        pass

    def describe_mount_target_security_groups(self, MountTargetId: str) -> DescribeMountTargetSecurityGroupsResponse:
        pass

    def describe_mount_targets(self, MaxItems: int=None, Marker: str=None, FileSystemId: str=None, MountTargetId: str=None) -> DescribeMountTargetsResponse:
        pass

    def describe_tags(self, FileSystemId: str, MaxItems: int=None, Marker: str=None) -> DescribeTagsResponse:
        pass

    def modify_mount_target_security_groups(self, MountTargetId: str, SecurityGroups: List[SecurityGroup]=None):
        pass

    def update_file_system(self, FileSystemId: str, ThroughputMode: str=None, ProvisionedThroughputInMibps: ProvisionedThroughputInMibps=None) -> FileSystemDescription:
        pass


class EKS(BaseClient):
    class CreateClusterRequest(Mapping):
        pass

    class CreateClusterResponse(Mapping):
        pass

    class VpcConfigRequest(Mapping):
        pass

    class DeleteClusterRequest(Mapping):
        pass

    class DeleteClusterResponse(Mapping):
        pass

    class DescribeClusterRequest(Mapping):
        pass

    class DescribeClusterResponse(Mapping):
        pass

    class DescribeUpdateRequest(Mapping):
        pass

    class DescribeUpdateResponse(Mapping):
        pass

    class ListClustersRequest(Mapping):
        pass

    class ListClustersResponse(Mapping):
        pass

    class ListUpdatesRequest(Mapping):
        pass

    class ListUpdatesResponse(Mapping):
        pass

    class UpdateClusterVersionRequest(Mapping):
        pass

    class UpdateClusterVersionResponse(Mapping):
        pass

    def create_cluster(self, resourcesVpcConfig: VpcConfigRequest, roleArn: str, name: str, version: str=None, clientRequestToken: str=None) -> CreateClusterResponse:
        pass

    def delete_cluster(self, name: str) -> DeleteClusterResponse:
        pass

    def describe_cluster(self, name: str) -> DescribeClusterResponse:
        pass

    def describe_update(self, updateId: str, name: str) -> DescribeUpdateResponse:
        pass

    def list_clusters(self, maxResults: int=None, nextToken: str=None) -> ListClustersResponse:
        pass

    def list_updates(self, name: str, nextToken: str=None, maxResults: int=None) -> ListUpdatesResponse:
        pass

    def update_cluster_version(self, version: str, name: str, clientRequestToken: str=None) -> UpdateClusterVersionResponse:
        pass


class ElastiCache(BaseClient):
    class AddTagsToResourceMessage(Mapping):
        pass

    class TagListMessage(Mapping):
        pass

    class Tag(Mapping):
        pass

    class AuthorizeCacheSecurityGroupIngressMessage(Mapping):
        pass

    class AuthorizeCacheSecurityGroupIngressResult(Mapping):
        pass

    class CopySnapshotMessage(Mapping):
        pass

    class CopySnapshotResult(Mapping):
        pass

    class CreateCacheClusterMessage(Mapping):
        pass

    class CreateCacheClusterResult(Mapping):
        pass

    class String(object):
        pass

    class BooleanOptional(object):
        pass

    class CreateCacheParameterGroupMessage(Mapping):
        pass

    class CreateCacheParameterGroupResult(Mapping):
        pass

    class CreateCacheSecurityGroupMessage(Mapping):
        pass

    class CreateCacheSecurityGroupResult(Mapping):
        pass

    class CreateCacheSubnetGroupMessage(Mapping):
        pass

    class CreateCacheSubnetGroupResult(Mapping):
        pass

    class CreateReplicationGroupMessage(Mapping):
        pass

    class CreateReplicationGroupResult(Mapping):
        pass

    class NodeGroupConfiguration(Mapping):
        pass

    class CreateSnapshotMessage(Mapping):
        pass

    class CreateSnapshotResult(Mapping):
        pass

    class DecreaseReplicaCountMessage(Mapping):
        pass

    class DecreaseReplicaCountResult(Mapping):
        pass

    class ConfigureShard(Mapping):
        pass

    class Boolean(object):
        pass

    class DeleteCacheClusterMessage(Mapping):
        pass

    class DeleteCacheClusterResult(Mapping):
        pass

    class DeleteCacheParameterGroupMessage(Mapping):
        pass

    class DeleteCacheSecurityGroupMessage(Mapping):
        pass

    class DeleteCacheSubnetGroupMessage(Mapping):
        pass

    class DeleteReplicationGroupMessage(Mapping):
        pass

    class DeleteReplicationGroupResult(Mapping):
        pass

    class DeleteSnapshotMessage(Mapping):
        pass

    class DeleteSnapshotResult(Mapping):
        pass

    class DescribeCacheClustersMessage(Mapping):
        pass

    class CacheClusterMessage(Mapping):
        pass

    class DescribeCacheEngineVersionsMessage(Mapping):
        pass

    class CacheEngineVersionMessage(Mapping):
        pass

    class DescribeCacheParameterGroupsMessage(Mapping):
        pass

    class CacheParameterGroupsMessage(Mapping):
        pass

    class DescribeCacheParametersMessage(Mapping):
        pass

    class CacheParameterGroupDetails(Mapping):
        pass

    class DescribeCacheSecurityGroupsMessage(Mapping):
        pass

    class CacheSecurityGroupMessage(Mapping):
        pass

    class DescribeCacheSubnetGroupsMessage(Mapping):
        pass

    class CacheSubnetGroupMessage(Mapping):
        pass

    class DescribeEngineDefaultParametersMessage(Mapping):
        pass

    class DescribeEngineDefaultParametersResult(Mapping):
        pass

    class DescribeEventsMessage(Mapping):
        pass

    class EventsMessage(Mapping):
        pass

    class TStamp(object):
        pass

    class DescribeReplicationGroupsMessage(Mapping):
        pass

    class ReplicationGroupMessage(Mapping):
        pass

    class DescribeReservedCacheNodesMessage(Mapping):
        pass

    class ReservedCacheNodeMessage(Mapping):
        pass

    class DescribeReservedCacheNodesOfferingsMessage(Mapping):
        pass

    class ReservedCacheNodesOfferingMessage(Mapping):
        pass

    class DescribeSnapshotsMessage(Mapping):
        pass

    class DescribeSnapshotsListMessage(Mapping):
        pass

    class IncreaseReplicaCountMessage(Mapping):
        pass

    class IncreaseReplicaCountResult(Mapping):
        pass

    class ListAllowedNodeTypeModificationsMessage(Mapping):
        pass

    class AllowedNodeTypeModificationsMessage(Mapping):
        pass

    class ListTagsForResourceMessage(Mapping):
        pass

    class ModifyCacheClusterMessage(Mapping):
        pass

    class ModifyCacheClusterResult(Mapping):
        pass

    class ModifyCacheParameterGroupMessage(Mapping):
        pass

    class CacheParameterGroupNameMessage(Mapping):
        pass

    class ParameterNameValue(Mapping):
        pass

    class ModifyCacheSubnetGroupMessage(Mapping):
        pass

    class ModifyCacheSubnetGroupResult(Mapping):
        pass

    class ModifyReplicationGroupMessage(Mapping):
        pass

    class ModifyReplicationGroupResult(Mapping):
        pass

    class ModifyReplicationGroupShardConfigurationMessage(Mapping):
        pass

    class ModifyReplicationGroupShardConfigurationResult(Mapping):
        pass

    class ReshardingConfiguration(Mapping):
        pass

    class AllowedNodeGroupId(object):
        pass

    class PurchaseReservedCacheNodesOfferingMessage(Mapping):
        pass

    class PurchaseReservedCacheNodesOfferingResult(Mapping):
        pass

    class RebootCacheClusterMessage(Mapping):
        pass

    class RebootCacheClusterResult(Mapping):
        pass

    class RemoveTagsFromResourceMessage(Mapping):
        pass

    class ResetCacheParameterGroupMessage(Mapping):
        pass

    class RevokeCacheSecurityGroupIngressMessage(Mapping):
        pass

    class RevokeCacheSecurityGroupIngressResult(Mapping):
        pass

    class TestFailoverMessage(Mapping):
        pass

    class TestFailoverResult(Mapping):
        pass

    def add_tags_to_resource(self, Tags: List[Tag], ResourceName: str) -> TagListMessage:
        pass

    def authorize_cache_security_group_ingress(self, EC2SecurityGroupOwnerId: str, EC2SecurityGroupName: str, CacheSecurityGroupName: str) -> AuthorizeCacheSecurityGroupIngressResult:
        pass

    def copy_snapshot(self, TargetSnapshotName: str, SourceSnapshotName: str, TargetBucket: str=None) -> CopySnapshotResult:
        pass

    def create_cache_cluster(self, CacheClusterId: str, ReplicationGroupId: str=None, AZMode: str=None, PreferredAvailabilityZone: str=None, PreferredAvailabilityZones: List[String]=None, NumCacheNodes: int=None, CacheNodeType: str=None, Engine: str=None, EngineVersion: str=None, CacheParameterGroupName: str=None, CacheSubnetGroupName: str=None, CacheSecurityGroupNames: List[String]=None, SecurityGroupIds: List[String]=None, Tags: List[Tag]=None, SnapshotArns: List[String]=None, SnapshotName: str=None, PreferredMaintenanceWindow: str=None, Port: int=None, NotificationTopicArn: str=None, AutoMinorVersionUpgrade: BooleanOptional=None, SnapshotRetentionLimit: int=None, SnapshotWindow: str=None, AuthToken: str=None) -> CreateCacheClusterResult:
        pass

    def create_cache_parameter_group(self, Description: str, CacheParameterGroupFamily: str, CacheParameterGroupName: str) -> CreateCacheParameterGroupResult:
        pass

    def create_cache_security_group(self, Description: str, CacheSecurityGroupName: str) -> CreateCacheSecurityGroupResult:
        pass

    def create_cache_subnet_group(self, SubnetIds: List[String], CacheSubnetGroupDescription: str, CacheSubnetGroupName: str) -> CreateCacheSubnetGroupResult:
        pass

    def create_replication_group(self, ReplicationGroupDescription: str, ReplicationGroupId: str, PrimaryClusterId: str=None, AutomaticFailoverEnabled: BooleanOptional=None, NumCacheClusters: int=None, PreferredCacheClusterAZs: List[String]=None, NumNodeGroups: int=None, ReplicasPerNodeGroup: int=None, NodeGroupConfiguration: List[NodeGroupConfiguration]=None, CacheNodeType: str=None, Engine: str=None, EngineVersion: str=None, CacheParameterGroupName: str=None, CacheSubnetGroupName: str=None, CacheSecurityGroupNames: List[String]=None, SecurityGroupIds: List[String]=None, Tags: List[Tag]=None, SnapshotArns: List[String]=None, SnapshotName: str=None, PreferredMaintenanceWindow: str=None, Port: int=None, NotificationTopicArn: str=None, AutoMinorVersionUpgrade: BooleanOptional=None, SnapshotRetentionLimit: int=None, SnapshotWindow: str=None, AuthToken: str=None, TransitEncryptionEnabled: BooleanOptional=None, AtRestEncryptionEnabled: BooleanOptional=None) -> CreateReplicationGroupResult:
        pass

    def create_snapshot(self, SnapshotName: str, ReplicationGroupId: str=None, CacheClusterId: str=None) -> CreateSnapshotResult:
        pass

    def decrease_replica_count(self, ApplyImmediately: Boolean, ReplicationGroupId: str, NewReplicaCount: int=None, ReplicaConfiguration: List[ConfigureShard]=None, ReplicasToRemove: List[String]=None) -> DecreaseReplicaCountResult:
        pass

    def delete_cache_cluster(self, CacheClusterId: str, FinalSnapshotIdentifier: str=None) -> DeleteCacheClusterResult:
        pass

    def delete_cache_parameter_group(self, CacheParameterGroupName: str):
        pass

    def delete_cache_security_group(self, CacheSecurityGroupName: str):
        pass

    def delete_cache_subnet_group(self, CacheSubnetGroupName: str):
        pass

    def delete_replication_group(self, ReplicationGroupId: str, RetainPrimaryCluster: BooleanOptional=None, FinalSnapshotIdentifier: str=None) -> DeleteReplicationGroupResult:
        pass

    def delete_snapshot(self, SnapshotName: str) -> DeleteSnapshotResult:
        pass

    def describe_cache_clusters(self, CacheClusterId: str=None, MaxRecords: int=None, Marker: str=None, ShowCacheNodeInfo: BooleanOptional=None, ShowCacheClustersNotInReplicationGroups: BooleanOptional=None) -> CacheClusterMessage:
        pass

    def describe_cache_engine_versions(self, Engine: str=None, EngineVersion: str=None, CacheParameterGroupFamily: str=None, MaxRecords: int=None, Marker: str=None, DefaultOnly: Boolean=None) -> CacheEngineVersionMessage:
        pass

    def describe_cache_parameter_groups(self, CacheParameterGroupName: str=None, MaxRecords: int=None, Marker: str=None) -> CacheParameterGroupsMessage:
        pass

    def describe_cache_parameters(self, CacheParameterGroupName: str, Source: str=None, MaxRecords: int=None, Marker: str=None) -> CacheParameterGroupDetails:
        pass

    def describe_cache_security_groups(self, CacheSecurityGroupName: str=None, MaxRecords: int=None, Marker: str=None) -> CacheSecurityGroupMessage:
        pass

    def describe_cache_subnet_groups(self, CacheSubnetGroupName: str=None, MaxRecords: int=None, Marker: str=None) -> CacheSubnetGroupMessage:
        pass

    def describe_engine_default_parameters(self, CacheParameterGroupFamily: str, MaxRecords: int=None, Marker: str=None) -> DescribeEngineDefaultParametersResult:
        pass

    def describe_events(self, SourceIdentifier: str=None, SourceType: str=None, StartTime: TStamp=None, EndTime: TStamp=None, Duration: int=None, MaxRecords: int=None, Marker: str=None) -> EventsMessage:
        pass

    def describe_replication_groups(self, ReplicationGroupId: str=None, MaxRecords: int=None, Marker: str=None) -> ReplicationGroupMessage:
        pass

    def describe_reserved_cache_nodes(self, ReservedCacheNodeId: str=None, ReservedCacheNodesOfferingId: str=None, CacheNodeType: str=None, Duration: str=None, ProductDescription: str=None, OfferingType: str=None, MaxRecords: int=None, Marker: str=None) -> ReservedCacheNodeMessage:
        pass

    def describe_reserved_cache_nodes_offerings(self, ReservedCacheNodesOfferingId: str=None, CacheNodeType: str=None, Duration: str=None, ProductDescription: str=None, OfferingType: str=None, MaxRecords: int=None, Marker: str=None) -> ReservedCacheNodesOfferingMessage:
        pass

    def describe_snapshots(self, ReplicationGroupId: str=None, CacheClusterId: str=None, SnapshotName: str=None, SnapshotSource: str=None, Marker: str=None, MaxRecords: int=None, ShowNodeGroupConfig: BooleanOptional=None) -> DescribeSnapshotsListMessage:
        pass

    def increase_replica_count(self, ApplyImmediately: Boolean, ReplicationGroupId: str, NewReplicaCount: int=None, ReplicaConfiguration: List[ConfigureShard]=None) -> IncreaseReplicaCountResult:
        pass

    def list_allowed_node_type_modifications(self, CacheClusterId: str=None, ReplicationGroupId: str=None) -> AllowedNodeTypeModificationsMessage:
        pass

    def list_tags_for_resource(self, ResourceName: str) -> TagListMessage:
        pass

    def modify_cache_cluster(self, CacheClusterId: str, NumCacheNodes: int=None, CacheNodeIdsToRemove: List[String]=None, AZMode: str=None, NewAvailabilityZones: List[String]=None, CacheSecurityGroupNames: List[String]=None, SecurityGroupIds: List[String]=None, PreferredMaintenanceWindow: str=None, NotificationTopicArn: str=None, CacheParameterGroupName: str=None, NotificationTopicStatus: str=None, ApplyImmediately: Boolean=None, EngineVersion: str=None, AutoMinorVersionUpgrade: BooleanOptional=None, SnapshotRetentionLimit: int=None, SnapshotWindow: str=None, CacheNodeType: str=None) -> ModifyCacheClusterResult:
        pass

    def modify_cache_parameter_group(self, ParameterNameValues: List[ParameterNameValue], CacheParameterGroupName: str) -> CacheParameterGroupNameMessage:
        pass

    def modify_cache_subnet_group(self, CacheSubnetGroupName: str, CacheSubnetGroupDescription: str=None, SubnetIds: List[String]=None) -> ModifyCacheSubnetGroupResult:
        pass

    def modify_replication_group(self, ReplicationGroupId: str, ReplicationGroupDescription: str=None, PrimaryClusterId: str=None, SnapshottingClusterId: str=None, AutomaticFailoverEnabled: BooleanOptional=None, CacheSecurityGroupNames: List[String]=None, SecurityGroupIds: List[String]=None, PreferredMaintenanceWindow: str=None, NotificationTopicArn: str=None, CacheParameterGroupName: str=None, NotificationTopicStatus: str=None, ApplyImmediately: Boolean=None, EngineVersion: str=None, AutoMinorVersionUpgrade: BooleanOptional=None, SnapshotRetentionLimit: int=None, SnapshotWindow: str=None, CacheNodeType: str=None, NodeGroupId: str=None) -> ModifyReplicationGroupResult:
        pass

    def modify_replication_group_shard_configuration(self, ApplyImmediately: Boolean, NodeGroupCount: int, ReplicationGroupId: str, ReshardingConfiguration: List[ReshardingConfiguration]=None, NodeGroupsToRemove: List[AllowedNodeGroupId]=None, NodeGroupsToRetain: List[AllowedNodeGroupId]=None) -> ModifyReplicationGroupShardConfigurationResult:
        pass

    def purchase_reserved_cache_nodes_offering(self, ReservedCacheNodesOfferingId: str, ReservedCacheNodeId: str=None, CacheNodeCount: int=None) -> PurchaseReservedCacheNodesOfferingResult:
        pass

    def reboot_cache_cluster(self, CacheNodeIdsToReboot: List[String], CacheClusterId: str) -> RebootCacheClusterResult:
        pass

    def remove_tags_from_resource(self, TagKeys: List[String], ResourceName: str) -> TagListMessage:
        pass

    def reset_cache_parameter_group(self, CacheParameterGroupName: str, ResetAllParameters: Boolean=None, ParameterNameValues: List[ParameterNameValue]=None) -> CacheParameterGroupNameMessage:
        pass

    def revoke_cache_security_group_ingress(self, EC2SecurityGroupOwnerId: str, EC2SecurityGroupName: str, CacheSecurityGroupName: str) -> RevokeCacheSecurityGroupIngressResult:
        pass

    def test_failover(self, NodeGroupId: str, ReplicationGroupId: str) -> TestFailoverResult:
        pass


class ElasticBeanstalk(BaseClient):
    class AbortEnvironmentUpdateMessage(Mapping):
        pass

    class ApplyEnvironmentManagedActionRequest(Mapping):
        pass

    class ApplyEnvironmentManagedActionResult(Mapping):
        pass

    class CheckDNSAvailabilityMessage(Mapping):
        pass

    class CheckDNSAvailabilityResultMessage(Mapping):
        pass

    class ComposeEnvironmentsMessage(Mapping):
        pass

    class EnvironmentDescriptionsMessage(Mapping):
        pass

    class VersionLabel(object):
        pass

    class CreateApplicationMessage(Mapping):
        pass

    class ApplicationDescriptionMessage(Mapping):
        pass

    class ApplicationResourceLifecycleConfig(Mapping):
        pass

    class CreateApplicationVersionMessage(Mapping):
        pass

    class ApplicationVersionDescriptionMessage(Mapping):
        pass

    class SourceBuildInformation(Mapping):
        pass

    class S3Location(Mapping):
        pass

    class BuildConfiguration(Mapping):
        pass

    class AutoCreateApplication(object):
        pass

    class ApplicationVersionProccess(object):
        pass

    class CreateConfigurationTemplateMessage(Mapping):
        pass

    class ConfigurationSettingsDescription(Mapping):
        pass

    class SourceConfiguration(Mapping):
        pass

    class ConfigurationOptionSetting(Mapping):
        pass

    class CreateEnvironmentMessage(Mapping):
        pass

    class EnvironmentDescription(Mapping):
        pass

    class EnvironmentTier(Mapping):
        pass

    class Tag(Mapping):
        pass

    class OptionSpecification(Mapping):
        pass

    class CreatePlatformVersionRequest(Mapping):
        pass

    class CreatePlatformVersionResult(Mapping):
        pass

    class CreateStorageLocationResultMessage(Mapping):
        pass

    class DeleteApplicationMessage(Mapping):
        pass

    class TerminateEnvForce(object):
        pass

    class DeleteApplicationVersionMessage(Mapping):
        pass

    class DeleteSourceBundle(object):
        pass

    class DeleteConfigurationTemplateMessage(Mapping):
        pass

    class DeleteEnvironmentConfigurationMessage(Mapping):
        pass

    class DeletePlatformVersionRequest(Mapping):
        pass

    class DeletePlatformVersionResult(Mapping):
        pass

    class DescribeAccountAttributesResult(Mapping):
        pass

    class DescribeApplicationVersionsMessage(Mapping):
        pass

    class ApplicationVersionDescriptionsMessage(Mapping):
        pass

    class DescribeApplicationsMessage(Mapping):
        pass

    class ApplicationDescriptionsMessage(Mapping):
        pass

    class ApplicationName(object):
        pass

    class DescribeConfigurationOptionsMessage(Mapping):
        pass

    class ConfigurationOptionsDescription(Mapping):
        pass

    class DescribeConfigurationSettingsMessage(Mapping):
        pass

    class ConfigurationSettingsDescriptions(Mapping):
        pass

    class DescribeEnvironmentHealthRequest(Mapping):
        pass

    class DescribeEnvironmentHealthResult(Mapping):
        pass

    class EnvironmentHealthAttribute(object):
        pass

    class DescribeEnvironmentManagedActionHistoryRequest(Mapping):
        pass

    class DescribeEnvironmentManagedActionHistoryResult(Mapping):
        pass

    class DescribeEnvironmentManagedActionsRequest(Mapping):
        pass

    class DescribeEnvironmentManagedActionsResult(Mapping):
        pass

    class DescribeEnvironmentResourcesMessage(Mapping):
        pass

    class EnvironmentResourceDescriptionsMessage(Mapping):
        pass

    class DescribeEnvironmentsMessage(Mapping):
        pass

    class EnvironmentId(object):
        pass

    class EnvironmentName(object):
        pass

    class IncludeDeleted(object):
        pass

    class IncludeDeletedBackTo(object):
        pass

    class DescribeEventsMessage(Mapping):
        pass

    class EventDescriptionsMessage(Mapping):
        pass

    class TimeFilterStart(object):
        pass

    class TimeFilterEnd(object):
        pass

    class DescribeInstancesHealthRequest(Mapping):
        pass

    class DescribeInstancesHealthResult(Mapping):
        pass

    class InstancesHealthAttribute(object):
        pass

    class DescribePlatformVersionRequest(Mapping):
        pass

    class DescribePlatformVersionResult(Mapping):
        pass

    class ListAvailableSolutionStacksResultMessage(Mapping):
        pass

    class ListPlatformVersionsRequest(Mapping):
        pass

    class ListPlatformVersionsResult(Mapping):
        pass

    class PlatformFilter(Mapping):
        pass

    class ListTagsForResourceMessage(Mapping):
        pass

    class ResourceTagsDescriptionMessage(Mapping):
        pass

    class RebuildEnvironmentMessage(Mapping):
        pass

    class RequestEnvironmentInfoMessage(Mapping):
        pass

    class RestartAppServerMessage(Mapping):
        pass

    class RetrieveEnvironmentInfoMessage(Mapping):
        pass

    class RetrieveEnvironmentInfoResultMessage(Mapping):
        pass

    class SwapEnvironmentCNAMEsMessage(Mapping):
        pass

    class TerminateEnvironmentMessage(Mapping):
        pass

    class TerminateEnvironmentResources(object):
        pass

    class ForceTerminate(object):
        pass

    class UpdateApplicationMessage(Mapping):
        pass

    class UpdateApplicationResourceLifecycleMessage(Mapping):
        pass

    class ApplicationResourceLifecycleDescriptionMessage(Mapping):
        pass

    class UpdateApplicationVersionMessage(Mapping):
        pass

    class UpdateConfigurationTemplateMessage(Mapping):
        pass

    class UpdateEnvironmentMessage(Mapping):
        pass

    class UpdateTagsForResourceMessage(Mapping):
        pass

    class TagKey(object):
        pass

    class ValidateConfigurationSettingsMessage(Mapping):
        pass

    class ConfigurationSettingsValidationMessages(Mapping):
        pass

    def abort_environment_update(self, EnvironmentId: str=None, EnvironmentName: str=None):
        pass

    def apply_environment_managed_action(self, ActionId: str, EnvironmentName: str=None, EnvironmentId: str=None) -> ApplyEnvironmentManagedActionResult:
        pass

    def check_dns_availability(self, CNAMEPrefix: str) -> CheckDNSAvailabilityResultMessage:
        pass

    def compose_environments(self, ApplicationName: str=None, GroupName: str=None, VersionLabels: List[VersionLabel]=None) -> EnvironmentDescriptionsMessage:
        pass

    def create_application(self, ApplicationName: str, Description: str=None, ResourceLifecycleConfig: ApplicationResourceLifecycleConfig=None) -> ApplicationDescriptionMessage:
        pass

    def create_application_version(self, VersionLabel: str, ApplicationName: str, Description: str=None, SourceBuildInformation: SourceBuildInformation=None, SourceBundle: S3Location=None, BuildConfiguration: BuildConfiguration=None, AutoCreateApplication: AutoCreateApplication=None, Process: ApplicationVersionProccess=None) -> ApplicationVersionDescriptionMessage:
        pass

    def create_configuration_template(self, TemplateName: str, ApplicationName: str, SolutionStackName: str=None, PlatformArn: str=None, SourceConfiguration: SourceConfiguration=None, EnvironmentId: str=None, Description: str=None, OptionSettings: List[ConfigurationOptionSetting]=None) -> ConfigurationSettingsDescription:
        pass

    def create_environment(self, ApplicationName: str, EnvironmentName: str=None, GroupName: str=None, Description: str=None, CNAMEPrefix: str=None, Tier: EnvironmentTier=None, Tags: List[Tag]=None, VersionLabel: str=None, TemplateName: str=None, SolutionStackName: str=None, PlatformArn: str=None, OptionSettings: List[ConfigurationOptionSetting]=None, OptionsToRemove: List[OptionSpecification]=None) -> EnvironmentDescription:
        pass

    def create_platform_version(self, PlatformDefinitionBundle: S3Location, PlatformVersion: str, PlatformName: str, EnvironmentName: str=None, OptionSettings: List[ConfigurationOptionSetting]=None) -> CreatePlatformVersionResult:
        pass

    def create_storage_location(self) -> CreateStorageLocationResultMessage:
        pass

    def delete_application(self, ApplicationName: str, TerminateEnvByForce: TerminateEnvForce=None):
        pass

    def delete_application_version(self, VersionLabel: str, ApplicationName: str, DeleteSourceBundle: DeleteSourceBundle=None):
        pass

    def delete_configuration_template(self, TemplateName: str, ApplicationName: str):
        pass

    def delete_environment_configuration(self, EnvironmentName: str, ApplicationName: str):
        pass

    def delete_platform_version(self, PlatformArn: str=None) -> DeletePlatformVersionResult:
        pass

    def describe_account_attributes(self) -> DescribeAccountAttributesResult:
        pass

    def describe_application_versions(self, ApplicationName: str=None, VersionLabels: List[VersionLabel]=None, MaxRecords: int=None, NextToken: str=None) -> ApplicationVersionDescriptionsMessage:
        pass

    def describe_applications(self, ApplicationNames: List[ApplicationName]=None) -> ApplicationDescriptionsMessage:
        pass

    def describe_configuration_options(self, ApplicationName: str=None, TemplateName: str=None, EnvironmentName: str=None, SolutionStackName: str=None, PlatformArn: str=None, Options: List[OptionSpecification]=None) -> ConfigurationOptionsDescription:
        pass

    def describe_configuration_settings(self, ApplicationName: str, TemplateName: str=None, EnvironmentName: str=None) -> ConfigurationSettingsDescriptions:
        pass

    def describe_environment_health(self, EnvironmentName: str=None, EnvironmentId: str=None, AttributeNames: List[EnvironmentHealthAttribute]=None) -> DescribeEnvironmentHealthResult:
        pass

    def describe_environment_managed_action_history(self, EnvironmentId: str=None, EnvironmentName: str=None, NextToken: str=None, MaxItems: int=None) -> DescribeEnvironmentManagedActionHistoryResult:
        pass

    def describe_environment_managed_actions(self, EnvironmentName: str=None, EnvironmentId: str=None, Status: str=None) -> DescribeEnvironmentManagedActionsResult:
        pass

    def describe_environment_resources(self, EnvironmentId: str=None, EnvironmentName: str=None) -> EnvironmentResourceDescriptionsMessage:
        pass

    def describe_environments(self, ApplicationName: str=None, VersionLabel: str=None, EnvironmentIds: List[EnvironmentId]=None, EnvironmentNames: List[EnvironmentName]=None, IncludeDeleted: IncludeDeleted=None, IncludedDeletedBackTo: IncludeDeletedBackTo=None, MaxRecords: int=None, NextToken: str=None) -> EnvironmentDescriptionsMessage:
        pass

    def describe_events(self, ApplicationName: str=None, VersionLabel: str=None, TemplateName: str=None, EnvironmentId: str=None, EnvironmentName: str=None, PlatformArn: str=None, RequestId: str=None, Severity: str=None, StartTime: TimeFilterStart=None, EndTime: TimeFilterEnd=None, MaxRecords: int=None, NextToken: str=None) -> EventDescriptionsMessage:
        pass

    def describe_instances_health(self, EnvironmentName: str=None, EnvironmentId: str=None, AttributeNames: List[InstancesHealthAttribute]=None, NextToken: str=None) -> DescribeInstancesHealthResult:
        pass

    def describe_platform_version(self, PlatformArn: str=None) -> DescribePlatformVersionResult:
        pass

    def list_available_solution_stacks(self) -> ListAvailableSolutionStacksResultMessage:
        pass

    def list_platform_versions(self, Filters: List[PlatformFilter]=None, MaxRecords: int=None, NextToken: str=None) -> ListPlatformVersionsResult:
        pass

    def list_tags_for_resource(self, ResourceArn: str) -> ResourceTagsDescriptionMessage:
        pass

    def rebuild_environment(self, EnvironmentId: str=None, EnvironmentName: str=None):
        pass

    def request_environment_info(self, InfoType: str, EnvironmentId: str=None, EnvironmentName: str=None):
        pass

    def restart_app_server(self, EnvironmentId: str=None, EnvironmentName: str=None):
        pass

    def retrieve_environment_info(self, InfoType: str, EnvironmentId: str=None, EnvironmentName: str=None) -> RetrieveEnvironmentInfoResultMessage:
        pass

    def swap_environment_cnames(self, SourceEnvironmentId: str=None, SourceEnvironmentName: str=None, DestinationEnvironmentId: str=None, DestinationEnvironmentName: str=None):
        pass

    def terminate_environment(self, EnvironmentId: str=None, EnvironmentName: str=None, TerminateResources: TerminateEnvironmentResources=None, ForceTerminate: ForceTerminate=None) -> EnvironmentDescription:
        pass

    def update_application(self, ApplicationName: str, Description: str=None) -> ApplicationDescriptionMessage:
        pass

    def update_application_resource_lifecycle(self, ResourceLifecycleConfig: ApplicationResourceLifecycleConfig, ApplicationName: str) -> ApplicationResourceLifecycleDescriptionMessage:
        pass

    def update_application_version(self, VersionLabel: str, ApplicationName: str, Description: str=None) -> ApplicationVersionDescriptionMessage:
        pass

    def update_configuration_template(self, TemplateName: str, ApplicationName: str, Description: str=None, OptionSettings: List[ConfigurationOptionSetting]=None, OptionsToRemove: List[OptionSpecification]=None) -> ConfigurationSettingsDescription:
        pass

    def update_environment(self, ApplicationName: str=None, EnvironmentId: str=None, EnvironmentName: str=None, GroupName: str=None, Description: str=None, Tier: EnvironmentTier=None, VersionLabel: str=None, TemplateName: str=None, SolutionStackName: str=None, PlatformArn: str=None, OptionSettings: List[ConfigurationOptionSetting]=None, OptionsToRemove: List[OptionSpecification]=None) -> EnvironmentDescription:
        pass

    def update_tags_for_resource(self, ResourceArn: str, TagsToAdd: List[Tag]=None, TagsToRemove: List[TagKey]=None):
        pass

    def validate_configuration_settings(self, OptionSettings: List[ConfigurationOptionSetting], ApplicationName: str, TemplateName: str=None, EnvironmentName: str=None) -> ConfigurationSettingsValidationMessages:
        pass


class ElasticTranscoder(BaseClient):
    class CancelJobRequest(Mapping):
        pass

    class CancelJobResponse(Mapping):
        pass

    class CreateJobRequest(Mapping):
        pass

    class CreateJobResponse(Mapping):
        pass

    class JobInput(Mapping):
        pass

    class CreateJobOutput(Mapping):
        pass

    class CreateJobPlaylist(Mapping):
        pass

    class UserMetadata(object):
        pass

    class CreatePipelineRequest(Mapping):
        pass

    class CreatePipelineResponse(Mapping):
        pass

    class Notifications(Mapping):
        pass

    class PipelineOutputConfig(Mapping):
        pass

    class CreatePresetRequest(Mapping):
        pass

    class CreatePresetResponse(Mapping):
        pass

    class VideoParameters(Mapping):
        pass

    class AudioParameters(Mapping):
        pass

    class Thumbnails(Mapping):
        pass

    class DeletePipelineRequest(Mapping):
        pass

    class DeletePipelineResponse(Mapping):
        pass

    class DeletePresetRequest(Mapping):
        pass

    class DeletePresetResponse(Mapping):
        pass

    class ListJobsByPipelineRequest(Mapping):
        pass

    class ListJobsByPipelineResponse(Mapping):
        pass

    class ListJobsByStatusRequest(Mapping):
        pass

    class ListJobsByStatusResponse(Mapping):
        pass

    class ListPipelinesRequest(Mapping):
        pass

    class ListPipelinesResponse(Mapping):
        pass

    class ListPresetsRequest(Mapping):
        pass

    class ListPresetsResponse(Mapping):
        pass

    class ReadJobRequest(Mapping):
        pass

    class ReadJobResponse(Mapping):
        pass

    class ReadPipelineRequest(Mapping):
        pass

    class ReadPipelineResponse(Mapping):
        pass

    class ReadPresetRequest(Mapping):
        pass

    class ReadPresetResponse(Mapping):
        pass

    class TestRoleRequest(Mapping):
        pass

    class TestRoleResponse(Mapping):
        pass

    class SnsTopic(object):
        pass

    class UpdatePipelineRequest(Mapping):
        pass

    class UpdatePipelineResponse(Mapping):
        pass

    class UpdatePipelineNotificationsRequest(Mapping):
        pass

    class UpdatePipelineNotificationsResponse(Mapping):
        pass

    class UpdatePipelineStatusRequest(Mapping):
        pass

    class UpdatePipelineStatusResponse(Mapping):
        pass

    def cancel_job(self, Id: str) -> CancelJobResponse:
        pass

    def create_job(self, PipelineId: str, Input: JobInput=None, Inputs: List[JobInput]=None, Output: CreateJobOutput=None, Outputs: List[CreateJobOutput]=None, OutputKeyPrefix: str=None, Playlists: List[CreateJobPlaylist]=None, UserMetadata: UserMetadata=None) -> CreateJobResponse:
        pass

    def create_pipeline(self, Role: str, InputBucket: str, Name: str, OutputBucket: str=None, AwsKmsKeyArn: str=None, Notifications: Notifications=None, ContentConfig: PipelineOutputConfig=None, ThumbnailConfig: PipelineOutputConfig=None) -> CreatePipelineResponse:
        pass

    def create_preset(self, Container: str, Name: str, Description: str=None, Video: VideoParameters=None, Audio: AudioParameters=None, Thumbnails: Thumbnails=None) -> CreatePresetResponse:
        pass

    def delete_pipeline(self, Id: str) -> DeletePipelineResponse:
        pass

    def delete_preset(self, Id: str) -> DeletePresetResponse:
        pass

    def list_jobs_by_pipeline(self, PipelineId: str, Ascending: str=None, PageToken: str=None) -> ListJobsByPipelineResponse:
        pass

    def list_jobs_by_status(self, Status: str, Ascending: str=None, PageToken: str=None) -> ListJobsByStatusResponse:
        pass

    def list_pipelines(self, Ascending: str=None, PageToken: str=None) -> ListPipelinesResponse:
        pass

    def list_presets(self, Ascending: str=None, PageToken: str=None) -> ListPresetsResponse:
        pass

    def read_job(self, Id: str) -> ReadJobResponse:
        pass

    def read_pipeline(self, Id: str) -> ReadPipelineResponse:
        pass

    def read_preset(self, Id: str) -> ReadPresetResponse:
        pass

    def test_role(self, Topics: List[SnsTopic], OutputBucket: str, InputBucket: str, Role: str) -> TestRoleResponse:
        pass

    def update_pipeline(self, Id: str, Name: str=None, InputBucket: str=None, Role: str=None, AwsKmsKeyArn: str=None, Notifications: Notifications=None, ContentConfig: PipelineOutputConfig=None, ThumbnailConfig: PipelineOutputConfig=None) -> UpdatePipelineResponse:
        pass

    def update_pipeline_notifications(self, Notifications: Notifications, Id: str) -> UpdatePipelineNotificationsResponse:
        pass

    def update_pipeline_status(self, Status: str, Id: str) -> UpdatePipelineStatusResponse:
        pass


class ElasticLoadBalancing(BaseClient):
    class AddTagsInput(Mapping):
        pass

    class AddTagsOutput(Mapping):
        pass

    class AccessPointName(object):
        pass

    class Tag(Mapping):
        pass

    class ApplySecurityGroupsToLoadBalancerInput(Mapping):
        pass

    class ApplySecurityGroupsToLoadBalancerOutput(Mapping):
        pass

    class SecurityGroupId(object):
        pass

    class AttachLoadBalancerToSubnetsInput(Mapping):
        pass

    class AttachLoadBalancerToSubnetsOutput(Mapping):
        pass

    class SubnetId(object):
        pass

    class ConfigureHealthCheckInput(Mapping):
        pass

    class ConfigureHealthCheckOutput(Mapping):
        pass

    class HealthCheck(Mapping):
        pass

    class CreateAppCookieStickinessPolicyInput(Mapping):
        pass

    class CreateAppCookieStickinessPolicyOutput(Mapping):
        pass

    class CreateLBCookieStickinessPolicyInput(Mapping):
        pass

    class CreateLBCookieStickinessPolicyOutput(Mapping):
        pass

    class CookieExpirationPeriod(object):
        pass

    class CreateAccessPointInput(Mapping):
        pass

    class CreateAccessPointOutput(Mapping):
        pass

    class Listener(Mapping):
        pass

    class AvailabilityZone(object):
        pass

    class CreateLoadBalancerListenerInput(Mapping):
        pass

    class CreateLoadBalancerListenerOutput(Mapping):
        pass

    class CreateLoadBalancerPolicyInput(Mapping):
        pass

    class CreateLoadBalancerPolicyOutput(Mapping):
        pass

    class PolicyAttribute(Mapping):
        pass

    class DeleteAccessPointInput(Mapping):
        pass

    class DeleteAccessPointOutput(Mapping):
        pass

    class DeleteLoadBalancerListenerInput(Mapping):
        pass

    class DeleteLoadBalancerListenerOutput(Mapping):
        pass

    class AccessPointPort(object):
        pass

    class DeleteLoadBalancerPolicyInput(Mapping):
        pass

    class DeleteLoadBalancerPolicyOutput(Mapping):
        pass

    class DeregisterEndPointsInput(Mapping):
        pass

    class DeregisterEndPointsOutput(Mapping):
        pass

    class Instance(Mapping):
        pass

    class DescribeAccountLimitsInput(Mapping):
        pass

    class DescribeAccountLimitsOutput(Mapping):
        pass

    class DescribeEndPointStateInput(Mapping):
        pass

    class DescribeEndPointStateOutput(Mapping):
        pass

    class DescribeLoadBalancerAttributesInput(Mapping):
        pass

    class DescribeLoadBalancerAttributesOutput(Mapping):
        pass

    class DescribeLoadBalancerPoliciesInput(Mapping):
        pass

    class DescribeLoadBalancerPoliciesOutput(Mapping):
        pass

    class PolicyName(object):
        pass

    class DescribeLoadBalancerPolicyTypesInput(Mapping):
        pass

    class DescribeLoadBalancerPolicyTypesOutput(Mapping):
        pass

    class PolicyTypeName(object):
        pass

    class DescribeAccessPointsInput(Mapping):
        pass

    class DescribeAccessPointsOutput(Mapping):
        pass

    class DescribeTagsInput(Mapping):
        pass

    class DescribeTagsOutput(Mapping):
        pass

    class DetachLoadBalancerFromSubnetsInput(Mapping):
        pass

    class DetachLoadBalancerFromSubnetsOutput(Mapping):
        pass

    class RemoveAvailabilityZonesInput(Mapping):
        pass

    class RemoveAvailabilityZonesOutput(Mapping):
        pass

    class AddAvailabilityZonesInput(Mapping):
        pass

    class AddAvailabilityZonesOutput(Mapping):
        pass

    class ModifyLoadBalancerAttributesInput(Mapping):
        pass

    class ModifyLoadBalancerAttributesOutput(Mapping):
        pass

    class LoadBalancerAttributes(Mapping):
        pass

    class RegisterEndPointsInput(Mapping):
        pass

    class RegisterEndPointsOutput(Mapping):
        pass

    class RemoveTagsInput(Mapping):
        pass

    class RemoveTagsOutput(Mapping):
        pass

    class TagKeyOnly(Mapping):
        pass

    class SetLoadBalancerListenerSSLCertificateInput(Mapping):
        pass

    class SetLoadBalancerListenerSSLCertificateOutput(Mapping):
        pass

    class SetLoadBalancerPoliciesForBackendServerInput(Mapping):
        pass

    class SetLoadBalancerPoliciesForBackendServerOutput(Mapping):
        pass

    class SetLoadBalancerPoliciesOfListenerInput(Mapping):
        pass

    class SetLoadBalancerPoliciesOfListenerOutput(Mapping):
        pass

    def add_tags(self, Tags: List[Tag], LoadBalancerNames: List[AccessPointName]) -> AddTagsOutput:
        pass

    def apply_security_groups_to_load_balancer(self, SecurityGroups: List[SecurityGroupId], LoadBalancerName: str) -> ApplySecurityGroupsToLoadBalancerOutput:
        pass

    def attach_load_balancer_to_subnets(self, Subnets: List[SubnetId], LoadBalancerName: str) -> AttachLoadBalancerToSubnetsOutput:
        pass

    def configure_health_check(self, HealthCheck: HealthCheck, LoadBalancerName: str) -> ConfigureHealthCheckOutput:
        pass

    def create_app_cookie_stickiness_policy(self, CookieName: str, PolicyName: str, LoadBalancerName: str) -> CreateAppCookieStickinessPolicyOutput:
        pass

    def create_lb_cookie_stickiness_policy(self, PolicyName: str, LoadBalancerName: str, CookieExpirationPeriod: CookieExpirationPeriod=None) -> CreateLBCookieStickinessPolicyOutput:
        pass

    def create_load_balancer(self, Listeners: List[Listener], LoadBalancerName: str, AvailabilityZones: List[AvailabilityZone]=None, Subnets: List[SubnetId]=None, SecurityGroups: List[SecurityGroupId]=None, Scheme: str=None, Tags: List[Tag]=None) -> CreateAccessPointOutput:
        pass

    def create_load_balancer_listeners(self, Listeners: List[Listener], LoadBalancerName: str) -> CreateLoadBalancerListenerOutput:
        pass

    def create_load_balancer_policy(self, PolicyTypeName: str, PolicyName: str, LoadBalancerName: str, PolicyAttributes: List[PolicyAttribute]=None) -> CreateLoadBalancerPolicyOutput:
        pass

    def delete_load_balancer(self, LoadBalancerName: str) -> DeleteAccessPointOutput:
        pass

    def delete_load_balancer_listeners(self, LoadBalancerPorts: List[AccessPointPort], LoadBalancerName: str) -> DeleteLoadBalancerListenerOutput:
        pass

    def delete_load_balancer_policy(self, PolicyName: str, LoadBalancerName: str) -> DeleteLoadBalancerPolicyOutput:
        pass

    def deregister_instances_from_load_balancer(self, Instances: List[Instance], LoadBalancerName: str) -> DeregisterEndPointsOutput:
        pass

    def describe_account_limits(self, Marker: str=None, PageSize: int=None) -> DescribeAccountLimitsOutput:
        pass

    def describe_instance_health(self, LoadBalancerName: str, Instances: List[Instance]=None) -> DescribeEndPointStateOutput:
        pass

    def describe_load_balancer_attributes(self, LoadBalancerName: str) -> DescribeLoadBalancerAttributesOutput:
        pass

    def describe_load_balancer_policies(self, LoadBalancerName: str=None, PolicyNames: List[PolicyName]=None) -> DescribeLoadBalancerPoliciesOutput:
        pass

    def describe_load_balancer_policy_types(self, PolicyTypeNames: List[PolicyTypeName]=None) -> DescribeLoadBalancerPolicyTypesOutput:
        pass

    def describe_load_balancers(self, LoadBalancerNames: List[AccessPointName]=None, Marker: str=None, PageSize: int=None) -> DescribeAccessPointsOutput:
        pass

    def describe_tags(self, LoadBalancerNames: List[AccessPointName]) -> DescribeTagsOutput:
        pass

    def detach_load_balancer_from_subnets(self, Subnets: List[SubnetId], LoadBalancerName: str) -> DetachLoadBalancerFromSubnetsOutput:
        pass

    def disable_availability_zones_for_load_balancer(self, AvailabilityZones: List[AvailabilityZone], LoadBalancerName: str) -> RemoveAvailabilityZonesOutput:
        pass

    def enable_availability_zones_for_load_balancer(self, AvailabilityZones: List[AvailabilityZone], LoadBalancerName: str) -> AddAvailabilityZonesOutput:
        pass

    def modify_load_balancer_attributes(self, LoadBalancerAttributes: LoadBalancerAttributes, LoadBalancerName: str) -> ModifyLoadBalancerAttributesOutput:
        pass

    def register_instances_with_load_balancer(self, Instances: List[Instance], LoadBalancerName: str) -> RegisterEndPointsOutput:
        pass

    def remove_tags(self, Tags: List[TagKeyOnly], LoadBalancerNames: List[AccessPointName]) -> RemoveTagsOutput:
        pass

    def set_load_balancer_listener_ssl_certificate(self, SSLCertificateId: str, LoadBalancerPort: int, LoadBalancerName: str) -> SetLoadBalancerListenerSSLCertificateOutput:
        pass

    def set_load_balancer_policies_for_backend_server(self, PolicyNames: List[PolicyName], InstancePort: int, LoadBalancerName: str) -> SetLoadBalancerPoliciesForBackendServerOutput:
        pass

    def set_load_balancer_policies_of_listener(self, PolicyNames: List[PolicyName], LoadBalancerPort: int, LoadBalancerName: str) -> SetLoadBalancerPoliciesOfListenerOutput:
        pass


class ElasticLoadBalancingv2(BaseClient):
    class AddListenerCertificatesInput(Mapping):
        pass

    class AddListenerCertificatesOutput(Mapping):
        pass

    class Certificate(Mapping):
        pass

    class AddTagsInput(Mapping):
        pass

    class AddTagsOutput(Mapping):
        pass

    class ResourceArn(object):
        pass

    class Tag(Mapping):
        pass

    class CreateListenerInput(Mapping):
        pass

    class CreateListenerOutput(Mapping):
        pass

    class Action(Mapping):
        pass

    class CreateLoadBalancerInput(Mapping):
        pass

    class CreateLoadBalancerOutput(Mapping):
        pass

    class SubnetId(object):
        pass

    class SubnetMapping(Mapping):
        pass

    class SecurityGroupId(object):
        pass

    class CreateRuleInput(Mapping):
        pass

    class CreateRuleOutput(Mapping):
        pass

    class RuleCondition(Mapping):
        pass

    class CreateTargetGroupInput(Mapping):
        pass

    class CreateTargetGroupOutput(Mapping):
        pass

    class HealthCheckEnabled(object):
        pass

    class Matcher(Mapping):
        pass

    class DeleteListenerInput(Mapping):
        pass

    class DeleteListenerOutput(Mapping):
        pass

    class DeleteLoadBalancerInput(Mapping):
        pass

    class DeleteLoadBalancerOutput(Mapping):
        pass

    class DeleteRuleInput(Mapping):
        pass

    class DeleteRuleOutput(Mapping):
        pass

    class DeleteTargetGroupInput(Mapping):
        pass

    class DeleteTargetGroupOutput(Mapping):
        pass

    class DeregisterTargetsInput(Mapping):
        pass

    class DeregisterTargetsOutput(Mapping):
        pass

    class TargetDescription(Mapping):
        pass

    class DescribeAccountLimitsInput(Mapping):
        pass

    class DescribeAccountLimitsOutput(Mapping):
        pass

    class DescribeListenerCertificatesInput(Mapping):
        pass

    class DescribeListenerCertificatesOutput(Mapping):
        pass

    class DescribeListenersInput(Mapping):
        pass

    class DescribeListenersOutput(Mapping):
        pass

    class ListenerArn(object):
        pass

    class DescribeLoadBalancerAttributesInput(Mapping):
        pass

    class DescribeLoadBalancerAttributesOutput(Mapping):
        pass

    class DescribeLoadBalancersInput(Mapping):
        pass

    class DescribeLoadBalancersOutput(Mapping):
        pass

    class LoadBalancerArn(object):
        pass

    class LoadBalancerName(object):
        pass

    class DescribeRulesInput(Mapping):
        pass

    class DescribeRulesOutput(Mapping):
        pass

    class RuleArn(object):
        pass

    class DescribeSSLPoliciesInput(Mapping):
        pass

    class DescribeSSLPoliciesOutput(Mapping):
        pass

    class SslPolicyName(object):
        pass

    class DescribeTagsInput(Mapping):
        pass

    class DescribeTagsOutput(Mapping):
        pass

    class DescribeTargetGroupAttributesInput(Mapping):
        pass

    class DescribeTargetGroupAttributesOutput(Mapping):
        pass

    class DescribeTargetGroupsInput(Mapping):
        pass

    class DescribeTargetGroupsOutput(Mapping):
        pass

    class TargetGroupArn(object):
        pass

    class TargetGroupName(object):
        pass

    class DescribeTargetHealthInput(Mapping):
        pass

    class DescribeTargetHealthOutput(Mapping):
        pass

    class ModifyListenerInput(Mapping):
        pass

    class ModifyListenerOutput(Mapping):
        pass

    class ModifyLoadBalancerAttributesInput(Mapping):
        pass

    class ModifyLoadBalancerAttributesOutput(Mapping):
        pass

    class LoadBalancerAttribute(Mapping):
        pass

    class ModifyRuleInput(Mapping):
        pass

    class ModifyRuleOutput(Mapping):
        pass

    class ModifyTargetGroupInput(Mapping):
        pass

    class ModifyTargetGroupOutput(Mapping):
        pass

    class ModifyTargetGroupAttributesInput(Mapping):
        pass

    class ModifyTargetGroupAttributesOutput(Mapping):
        pass

    class TargetGroupAttribute(Mapping):
        pass

    class RegisterTargetsInput(Mapping):
        pass

    class RegisterTargetsOutput(Mapping):
        pass

    class RemoveListenerCertificatesInput(Mapping):
        pass

    class RemoveListenerCertificatesOutput(Mapping):
        pass

    class RemoveTagsInput(Mapping):
        pass

    class RemoveTagsOutput(Mapping):
        pass

    class TagKey(object):
        pass

    class SetIpAddressTypeInput(Mapping):
        pass

    class SetIpAddressTypeOutput(Mapping):
        pass

    class SetRulePrioritiesInput(Mapping):
        pass

    class SetRulePrioritiesOutput(Mapping):
        pass

    class RulePriorityPair(Mapping):
        pass

    class SetSecurityGroupsInput(Mapping):
        pass

    class SetSecurityGroupsOutput(Mapping):
        pass

    class SetSubnetsInput(Mapping):
        pass

    class SetSubnetsOutput(Mapping):
        pass

    def add_listener_certificates(self, Certificates: List[Certificate], ListenerArn: str) -> AddListenerCertificatesOutput:
        pass

    def add_tags(self, Tags: List[Tag], ResourceArns: List[ResourceArn]) -> AddTagsOutput:
        pass

    def create_listener(self, DefaultActions: List[Action], Port: int, Protocol: str, LoadBalancerArn: str, SslPolicy: str=None, Certificates: List[Certificate]=None) -> CreateListenerOutput:
        pass

    def create_load_balancer(self, Name: str, Subnets: List[SubnetId]=None, SubnetMappings: List[SubnetMapping]=None, SecurityGroups: List[SecurityGroupId]=None, Scheme: str=None, Tags: List[Tag]=None, Type: str=None, IpAddressType: str=None) -> CreateLoadBalancerOutput:
        pass

    def create_rule(self, Actions: List[Action], Priority: int, Conditions: List[RuleCondition], ListenerArn: str) -> CreateRuleOutput:
        pass

    def create_target_group(self, Name: str, Protocol: str=None, Port: int=None, VpcId: str=None, HealthCheckProtocol: str=None, HealthCheckPort: str=None, HealthCheckEnabled: HealthCheckEnabled=None, HealthCheckPath: str=None, HealthCheckIntervalSeconds: int=None, HealthCheckTimeoutSeconds: int=None, HealthyThresholdCount: int=None, UnhealthyThresholdCount: int=None, Matcher: Matcher=None, TargetType: str=None) -> CreateTargetGroupOutput:
        pass

    def delete_listener(self, ListenerArn: str) -> DeleteListenerOutput:
        pass

    def delete_load_balancer(self, LoadBalancerArn: str) -> DeleteLoadBalancerOutput:
        pass

    def delete_rule(self, RuleArn: str) -> DeleteRuleOutput:
        pass

    def delete_target_group(self, TargetGroupArn: str) -> DeleteTargetGroupOutput:
        pass

    def deregister_targets(self, Targets: List[TargetDescription], TargetGroupArn: str) -> DeregisterTargetsOutput:
        pass

    def describe_account_limits(self, Marker: str=None, PageSize: int=None) -> DescribeAccountLimitsOutput:
        pass

    def describe_listener_certificates(self, ListenerArn: str, Marker: str=None, PageSize: int=None) -> DescribeListenerCertificatesOutput:
        pass

    def describe_listeners(self, LoadBalancerArn: str=None, ListenerArns: List[ListenerArn]=None, Marker: str=None, PageSize: int=None) -> DescribeListenersOutput:
        pass

    def describe_load_balancer_attributes(self, LoadBalancerArn: str) -> DescribeLoadBalancerAttributesOutput:
        pass

    def describe_load_balancers(self, LoadBalancerArns: List[LoadBalancerArn]=None, Names: List[LoadBalancerName]=None, Marker: str=None, PageSize: int=None) -> DescribeLoadBalancersOutput:
        pass

    def describe_rules(self, ListenerArn: str=None, RuleArns: List[RuleArn]=None, Marker: str=None, PageSize: int=None) -> DescribeRulesOutput:
        pass

    def describe_ssl_policies(self, Names: List[SslPolicyName]=None, Marker: str=None, PageSize: int=None) -> DescribeSSLPoliciesOutput:
        pass

    def describe_tags(self, ResourceArns: List[ResourceArn]) -> DescribeTagsOutput:
        pass

    def describe_target_group_attributes(self, TargetGroupArn: str) -> DescribeTargetGroupAttributesOutput:
        pass

    def describe_target_groups(self, LoadBalancerArn: str=None, TargetGroupArns: List[TargetGroupArn]=None, Names: List[TargetGroupName]=None, Marker: str=None, PageSize: int=None) -> DescribeTargetGroupsOutput:
        pass

    def describe_target_health(self, TargetGroupArn: str, Targets: List[TargetDescription]=None) -> DescribeTargetHealthOutput:
        pass

    def modify_listener(self, ListenerArn: str, Port: int=None, Protocol: str=None, SslPolicy: str=None, Certificates: List[Certificate]=None, DefaultActions: List[Action]=None) -> ModifyListenerOutput:
        pass

    def modify_load_balancer_attributes(self, Attributes: List[LoadBalancerAttribute], LoadBalancerArn: str) -> ModifyLoadBalancerAttributesOutput:
        pass

    def modify_rule(self, RuleArn: str, Conditions: List[RuleCondition]=None, Actions: List[Action]=None) -> ModifyRuleOutput:
        pass

    def modify_target_group(self, TargetGroupArn: str, HealthCheckProtocol: str=None, HealthCheckPort: str=None, HealthCheckPath: str=None, HealthCheckEnabled: HealthCheckEnabled=None, HealthCheckIntervalSeconds: int=None, HealthCheckTimeoutSeconds: int=None, HealthyThresholdCount: int=None, UnhealthyThresholdCount: int=None, Matcher: Matcher=None) -> ModifyTargetGroupOutput:
        pass

    def modify_target_group_attributes(self, Attributes: List[TargetGroupAttribute], TargetGroupArn: str) -> ModifyTargetGroupAttributesOutput:
        pass

    def register_targets(self, Targets: List[TargetDescription], TargetGroupArn: str) -> RegisterTargetsOutput:
        pass

    def remove_listener_certificates(self, Certificates: List[Certificate], ListenerArn: str) -> RemoveListenerCertificatesOutput:
        pass

    def remove_tags(self, TagKeys: List[TagKey], ResourceArns: List[ResourceArn]) -> RemoveTagsOutput:
        pass

    def set_ip_address_type(self, IpAddressType: str, LoadBalancerArn: str) -> SetIpAddressTypeOutput:
        pass

    def set_rule_priorities(self, RulePriorities: List[RulePriorityPair]) -> SetRulePrioritiesOutput:
        pass

    def set_security_groups(self, SecurityGroups: List[SecurityGroupId], LoadBalancerArn: str) -> SetSecurityGroupsOutput:
        pass

    def set_subnets(self, LoadBalancerArn: str, Subnets: List[SubnetId]=None, SubnetMappings: List[SubnetMapping]=None) -> SetSubnetsOutput:
        pass


class EMR(BaseClient):
    class AddInstanceFleetInput(Mapping):
        pass

    class AddInstanceFleetOutput(Mapping):
        pass

    class InstanceFleetConfig(Mapping):
        pass

    class AddInstanceGroupsInput(Mapping):
        pass

    class AddInstanceGroupsOutput(Mapping):
        pass

    class InstanceGroupConfig(Mapping):
        pass

    class AddJobFlowStepsInput(Mapping):
        pass

    class AddJobFlowStepsOutput(Mapping):
        pass

    class StepConfig(Mapping):
        pass

    class AddTagsInput(Mapping):
        pass

    class AddTagsOutput(Mapping):
        pass

    class Tag(Mapping):
        pass

    class CancelStepsInput(Mapping):
        pass

    class CancelStepsOutput(Mapping):
        pass

    class XmlStringMaxLen256(object):
        pass

    class CreateSecurityConfigurationInput(Mapping):
        pass

    class CreateSecurityConfigurationOutput(Mapping):
        pass

    class DeleteSecurityConfigurationInput(Mapping):
        pass

    class DeleteSecurityConfigurationOutput(Mapping):
        pass

    class DescribeClusterInput(Mapping):
        pass

    class DescribeClusterOutput(Mapping):
        pass

    class DescribeJobFlowsInput(Mapping):
        pass

    class DescribeJobFlowsOutput(Mapping):
        pass

    class Date(object):
        pass

    class XmlString(object):
        pass

    class JobFlowExecutionState(object):
        pass

    class DescribeSecurityConfigurationInput(Mapping):
        pass

    class DescribeSecurityConfigurationOutput(Mapping):
        pass

    class DescribeStepInput(Mapping):
        pass

    class DescribeStepOutput(Mapping):
        pass

    class ListBootstrapActionsInput(Mapping):
        pass

    class ListBootstrapActionsOutput(Mapping):
        pass

    class ListClustersInput(Mapping):
        pass

    class ListClustersOutput(Mapping):
        pass

    class ClusterState(object):
        pass

    class ListInstanceFleetsInput(Mapping):
        pass

    class ListInstanceFleetsOutput(Mapping):
        pass

    class ListInstanceGroupsInput(Mapping):
        pass

    class ListInstanceGroupsOutput(Mapping):
        pass

    class ListInstancesInput(Mapping):
        pass

    class ListInstancesOutput(Mapping):
        pass

    class InstanceGroupType(object):
        pass

    class InstanceState(object):
        pass

    class ListSecurityConfigurationsInput(Mapping):
        pass

    class ListSecurityConfigurationsOutput(Mapping):
        pass

    class ListStepsInput(Mapping):
        pass

    class ListStepsOutput(Mapping):
        pass

    class StepState(object):
        pass

    class ModifyInstanceFleetInput(Mapping):
        pass

    class InstanceFleetModifyConfig(Mapping):
        pass

    class ModifyInstanceGroupsInput(Mapping):
        pass

    class InstanceGroupModifyConfig(Mapping):
        pass

    class PutAutoScalingPolicyInput(Mapping):
        pass

    class PutAutoScalingPolicyOutput(Mapping):
        pass

    class AutoScalingPolicy(Mapping):
        pass

    class RemoveAutoScalingPolicyInput(Mapping):
        pass

    class RemoveAutoScalingPolicyOutput(Mapping):
        pass

    class RemoveTagsInput(Mapping):
        pass

    class RemoveTagsOutput(Mapping):
        pass

    class String(object):
        pass

    class RunJobFlowInput(Mapping):
        pass

    class RunJobFlowOutput(Mapping):
        pass

    class JobFlowInstancesConfig(Mapping):
        pass

    class BootstrapActionConfig(Mapping):
        pass

    class SupportedProductConfig(Mapping):
        pass

    class Application(Mapping):
        pass

    class Configuration(Mapping):
        pass

    class Boolean(object):
        pass

    class KerberosAttributes(Mapping):
        pass

    class SetTerminationProtectionInput(Mapping):
        pass

    class SetVisibleToAllUsersInput(Mapping):
        pass

    class TerminateJobFlowsInput(Mapping):
        pass

    def add_instance_fleet(self, InstanceFleet: InstanceFleetConfig, ClusterId: str) -> AddInstanceFleetOutput:
        pass

    def add_instance_groups(self, JobFlowId: str, InstanceGroups: List[InstanceGroupConfig]) -> AddInstanceGroupsOutput:
        pass

    def add_job_flow_steps(self, Steps: List[StepConfig], JobFlowId: str) -> AddJobFlowStepsOutput:
        pass

    def add_tags(self, Tags: List[Tag], ResourceId: str) -> AddTagsOutput:
        pass

    def cancel_steps(self, ClusterId: str=None, StepIds: List[XmlStringMaxLen256]=None) -> CancelStepsOutput:
        pass

    def create_security_configuration(self, SecurityConfiguration: str, Name: str) -> CreateSecurityConfigurationOutput:
        pass

    def delete_security_configuration(self, Name: str) -> DeleteSecurityConfigurationOutput:
        pass

    def describe_cluster(self, ClusterId: str) -> DescribeClusterOutput:
        pass

    def describe_job_flows(self, CreatedAfter: Date=None, CreatedBefore: Date=None, JobFlowIds: List[XmlString]=None, JobFlowStates: List[JobFlowExecutionState]=None) -> DescribeJobFlowsOutput:
        pass

    def describe_security_configuration(self, Name: str) -> DescribeSecurityConfigurationOutput:
        pass

    def describe_step(self, StepId: str, ClusterId: str) -> DescribeStepOutput:
        pass

    def list_bootstrap_actions(self, ClusterId: str, Marker: str=None) -> ListBootstrapActionsOutput:
        pass

    def list_clusters(self, CreatedAfter: Date=None, CreatedBefore: Date=None, ClusterStates: List[ClusterState]=None, Marker: str=None) -> ListClustersOutput:
        pass

    def list_instance_fleets(self, ClusterId: str, Marker: str=None) -> ListInstanceFleetsOutput:
        pass

    def list_instance_groups(self, ClusterId: str, Marker: str=None) -> ListInstanceGroupsOutput:
        pass

    def list_instances(self, ClusterId: str, InstanceGroupId: str=None, InstanceGroupTypes: List[InstanceGroupType]=None, InstanceFleetId: str=None, InstanceFleetType: str=None, InstanceStates: List[InstanceState]=None, Marker: str=None) -> ListInstancesOutput:
        pass

    def list_security_configurations(self, Marker: str=None) -> ListSecurityConfigurationsOutput:
        pass

    def list_steps(self, ClusterId: str, StepStates: List[StepState]=None, StepIds: List[XmlString]=None, Marker: str=None) -> ListStepsOutput:
        pass

    def modify_instance_fleet(self, InstanceFleet: InstanceFleetModifyConfig, ClusterId: str):
        pass

    def modify_instance_groups(self, ClusterId: str=None, InstanceGroups: List[InstanceGroupModifyConfig]=None):
        pass

    def put_auto_scaling_policy(self, AutoScalingPolicy: AutoScalingPolicy, InstanceGroupId: str, ClusterId: str) -> PutAutoScalingPolicyOutput:
        pass

    def remove_auto_scaling_policy(self, InstanceGroupId: str, ClusterId: str) -> RemoveAutoScalingPolicyOutput:
        pass

    def remove_tags(self, TagKeys: List[String], ResourceId: str) -> RemoveTagsOutput:
        pass

    def run_job_flow(self, Instances: JobFlowInstancesConfig, Name: str, LogUri: str=None, AdditionalInfo: str=None, AmiVersion: str=None, ReleaseLabel: str=None, Steps: List[StepConfig]=None, BootstrapActions: List[BootstrapActionConfig]=None, SupportedProducts: List[XmlStringMaxLen256]=None, NewSupportedProducts: List[SupportedProductConfig]=None, Applications: List[Application]=None, Configurations: List[Configuration]=None, VisibleToAllUsers: Boolean=None, JobFlowRole: str=None, ServiceRole: str=None, Tags: List[Tag]=None, SecurityConfiguration: str=None, AutoScalingRole: str=None, ScaleDownBehavior: str=None, CustomAmiId: str=None, EbsRootVolumeSize: int=None, RepoUpgradeOnBoot: str=None, KerberosAttributes: KerberosAttributes=None) -> RunJobFlowOutput:
        pass

    def set_termination_protection(self, TerminationProtected: Boolean, JobFlowIds: List[XmlString]):
        pass

    def set_visible_to_all_users(self, VisibleToAllUsers: Boolean, JobFlowIds: List[XmlString]):
        pass

    def terminate_job_flows(self, JobFlowIds: List[XmlString]):
        pass


class ElasticsearchService(BaseClient):
    class AddTagsRequest(Mapping):
        pass

    class Tag(Mapping):
        pass

    class CancelElasticsearchServiceSoftwareUpdateRequest(Mapping):
        pass

    class CancelElasticsearchServiceSoftwareUpdateResponse(Mapping):
        pass

    class CreateElasticsearchDomainRequest(Mapping):
        pass

    class CreateElasticsearchDomainResponse(Mapping):
        pass

    class ElasticsearchClusterConfig(Mapping):
        pass

    class EBSOptions(Mapping):
        pass

    class SnapshotOptions(Mapping):
        pass

    class VPCOptions(Mapping):
        pass

    class CognitoOptions(Mapping):
        pass

    class EncryptionAtRestOptions(Mapping):
        pass

    class NodeToNodeEncryptionOptions(Mapping):
        pass

    class AdvancedOptions(object):
        pass

    class LogPublishingOptions(object):
        pass

    class DeleteElasticsearchDomainRequest(Mapping):
        pass

    class DeleteElasticsearchDomainResponse(Mapping):
        pass

    class DescribeElasticsearchDomainRequest(Mapping):
        pass

    class DescribeElasticsearchDomainResponse(Mapping):
        pass

    class DescribeElasticsearchDomainConfigRequest(Mapping):
        pass

    class DescribeElasticsearchDomainConfigResponse(Mapping):
        pass

    class DescribeElasticsearchDomainsRequest(Mapping):
        pass

    class DescribeElasticsearchDomainsResponse(Mapping):
        pass

    class DomainName(object):
        pass

    class DescribeElasticsearchInstanceTypeLimitsRequest(Mapping):
        pass

    class DescribeElasticsearchInstanceTypeLimitsResponse(Mapping):
        pass

    class DescribeReservedElasticsearchInstanceOfferingsRequest(Mapping):
        pass

    class DescribeReservedElasticsearchInstanceOfferingsResponse(Mapping):
        pass

    class DescribeReservedElasticsearchInstancesRequest(Mapping):
        pass

    class DescribeReservedElasticsearchInstancesResponse(Mapping):
        pass

    class GetCompatibleElasticsearchVersionsRequest(Mapping):
        pass

    class GetCompatibleElasticsearchVersionsResponse(Mapping):
        pass

    class GetUpgradeHistoryRequest(Mapping):
        pass

    class GetUpgradeHistoryResponse(Mapping):
        pass

    class GetUpgradeStatusRequest(Mapping):
        pass

    class GetUpgradeStatusResponse(Mapping):
        pass

    class ListDomainNamesResponse(Mapping):
        pass

    class ListElasticsearchInstanceTypesRequest(Mapping):
        pass

    class ListElasticsearchInstanceTypesResponse(Mapping):
        pass

    class ListElasticsearchVersionsRequest(Mapping):
        pass

    class ListElasticsearchVersionsResponse(Mapping):
        pass

    class ListTagsRequest(Mapping):
        pass

    class ListTagsResponse(Mapping):
        pass

    class PurchaseReservedElasticsearchInstanceOfferingRequest(Mapping):
        pass

    class PurchaseReservedElasticsearchInstanceOfferingResponse(Mapping):
        pass

    class RemoveTagsRequest(Mapping):
        pass

    class String(object):
        pass

    class StartElasticsearchServiceSoftwareUpdateRequest(Mapping):
        pass

    class StartElasticsearchServiceSoftwareUpdateResponse(Mapping):
        pass

    class UpdateElasticsearchDomainConfigRequest(Mapping):
        pass

    class UpdateElasticsearchDomainConfigResponse(Mapping):
        pass

    class UpgradeElasticsearchDomainRequest(Mapping):
        pass

    class UpgradeElasticsearchDomainResponse(Mapping):
        pass

    class Boolean(object):
        pass

    def add_tags(self, TagList: List[Tag], ARN: str):
        pass

    def cancel_elasticsearch_service_software_update(self, DomainName: str) -> CancelElasticsearchServiceSoftwareUpdateResponse:
        pass

    def create_elasticsearch_domain(self, DomainName: str, ElasticsearchVersion: str=None, ElasticsearchClusterConfig: ElasticsearchClusterConfig=None, EBSOptions: EBSOptions=None, AccessPolicies: str=None, SnapshotOptions: SnapshotOptions=None, VPCOptions: VPCOptions=None, CognitoOptions: CognitoOptions=None, EncryptionAtRestOptions: EncryptionAtRestOptions=None, NodeToNodeEncryptionOptions: NodeToNodeEncryptionOptions=None, AdvancedOptions: AdvancedOptions=None, LogPublishingOptions: LogPublishingOptions=None) -> CreateElasticsearchDomainResponse:
        pass

    def delete_elasticsearch_domain(self, DomainName: str) -> DeleteElasticsearchDomainResponse:
        pass

    def delete_elasticsearch_service_role(self):
        pass

    def describe_elasticsearch_domain(self, DomainName: str) -> DescribeElasticsearchDomainResponse:
        pass

    def describe_elasticsearch_domain_config(self, DomainName: str) -> DescribeElasticsearchDomainConfigResponse:
        pass

    def describe_elasticsearch_domains(self, DomainNames: List[DomainName]) -> DescribeElasticsearchDomainsResponse:
        pass

    def describe_elasticsearch_instance_type_limits(self, ElasticsearchVersion: str, InstanceType: str, DomainName: str=None) -> DescribeElasticsearchInstanceTypeLimitsResponse:
        pass

    def describe_reserved_elasticsearch_instance_offerings(self, ReservedElasticsearchInstanceOfferingId: str=None, MaxResults: int=None, NextToken: str=None) -> DescribeReservedElasticsearchInstanceOfferingsResponse:
        pass

    def describe_reserved_elasticsearch_instances(self, ReservedElasticsearchInstanceId: str=None, MaxResults: int=None, NextToken: str=None) -> DescribeReservedElasticsearchInstancesResponse:
        pass

    def get_compatible_elasticsearch_versions(self, DomainName: str=None) -> GetCompatibleElasticsearchVersionsResponse:
        pass

    def get_upgrade_history(self, DomainName: str, MaxResults: int=None, NextToken: str=None) -> GetUpgradeHistoryResponse:
        pass

    def get_upgrade_status(self, DomainName: str) -> GetUpgradeStatusResponse:
        pass

    def list_domain_names(self) -> ListDomainNamesResponse:
        pass

    def list_elasticsearch_instance_types(self, ElasticsearchVersion: str, DomainName: str=None, MaxResults: int=None, NextToken: str=None) -> ListElasticsearchInstanceTypesResponse:
        pass

    def list_elasticsearch_versions(self, MaxResults: int=None, NextToken: str=None) -> ListElasticsearchVersionsResponse:
        pass

    def list_tags(self, ARN: str) -> ListTagsResponse:
        pass

    def purchase_reserved_elasticsearch_instance_offering(self, ReservationName: str, ReservedElasticsearchInstanceOfferingId: str, InstanceCount: int=None) -> PurchaseReservedElasticsearchInstanceOfferingResponse:
        pass

    def remove_tags(self, TagKeys: List[String], ARN: str):
        pass

    def start_elasticsearch_service_software_update(self, DomainName: str) -> StartElasticsearchServiceSoftwareUpdateResponse:
        pass

    def update_elasticsearch_domain_config(self, DomainName: str, ElasticsearchClusterConfig: ElasticsearchClusterConfig=None, EBSOptions: EBSOptions=None, SnapshotOptions: SnapshotOptions=None, VPCOptions: VPCOptions=None, CognitoOptions: CognitoOptions=None, AdvancedOptions: AdvancedOptions=None, AccessPolicies: str=None, LogPublishingOptions: LogPublishingOptions=None) -> UpdateElasticsearchDomainConfigResponse:
        pass

    def upgrade_elasticsearch_domain(self, TargetVersion: str, DomainName: str, PerformCheckOnly: Boolean=None) -> UpgradeElasticsearchDomainResponse:
        pass


class CloudWatchEvents(BaseClient):
    class DeleteRuleRequest(Mapping):
        pass

    class Boolean(object):
        pass

    class DescribeEventBusRequest(Mapping):
        pass

    class DescribeEventBusResponse(Mapping):
        pass

    class DescribeRuleRequest(Mapping):
        pass

    class DescribeRuleResponse(Mapping):
        pass

    class DisableRuleRequest(Mapping):
        pass

    class EnableRuleRequest(Mapping):
        pass

    class ListRuleNamesByTargetRequest(Mapping):
        pass

    class ListRuleNamesByTargetResponse(Mapping):
        pass

    class ListRulesRequest(Mapping):
        pass

    class ListRulesResponse(Mapping):
        pass

    class ListTargetsByRuleRequest(Mapping):
        pass

    class ListTargetsByRuleResponse(Mapping):
        pass

    class PutEventsRequest(Mapping):
        pass

    class PutEventsResponse(Mapping):
        pass

    class PutEventsRequestEntry(Mapping):
        pass

    class PutPermissionRequest(Mapping):
        pass

    class Condition(Mapping):
        pass

    class PutRuleRequest(Mapping):
        pass

    class PutRuleResponse(Mapping):
        pass

    class PutTargetsRequest(Mapping):
        pass

    class PutTargetsResponse(Mapping):
        pass

    class Target(Mapping):
        pass

    class RemovePermissionRequest(Mapping):
        pass

    class RemoveTargetsRequest(Mapping):
        pass

    class RemoveTargetsResponse(Mapping):
        pass

    class TargetId(object):
        pass

    class TestEventPatternRequest(Mapping):
        pass

    class TestEventPatternResponse(Mapping):
        pass

    def delete_rule(self, Name: str, Force: Boolean=None):
        pass

    def describe_event_bus(self) -> DescribeEventBusResponse:
        pass

    def describe_rule(self, Name: str) -> DescribeRuleResponse:
        pass

    def disable_rule(self, Name: str):
        pass

    def enable_rule(self, Name: str):
        pass

    def list_rule_names_by_target(self, TargetArn: str, NextToken: str=None, Limit: int=None) -> ListRuleNamesByTargetResponse:
        pass

    def list_rules(self, NamePrefix: str=None, NextToken: str=None, Limit: int=None) -> ListRulesResponse:
        pass

    def list_targets_by_rule(self, Rule: str, NextToken: str=None, Limit: int=None) -> ListTargetsByRuleResponse:
        pass

    def put_events(self, Entries: List[PutEventsRequestEntry]) -> PutEventsResponse:
        pass

    def put_permission(self, StatementId: str, Principal: str, Action: str, Condition: Condition=None):
        pass

    def put_rule(self, Name: str, ScheduleExpression: str=None, EventPattern: str=None, State: str=None, Description: str=None, RoleArn: str=None) -> PutRuleResponse:
        pass

    def put_targets(self, Targets: List[Target], Rule: str) -> PutTargetsResponse:
        pass

    def remove_permission(self, StatementId: str):
        pass

    def remove_targets(self, Ids: List[TargetId], Rule: str, Force: Boolean=None) -> RemoveTargetsResponse:
        pass

    def test_event_pattern(self, Event: str, EventPattern: str) -> TestEventPatternResponse:
        pass


class Firehose(BaseClient):
    class CreateDeliveryStreamInput(Mapping):
        pass

    class CreateDeliveryStreamOutput(Mapping):
        pass

    class KinesisStreamSourceConfiguration(Mapping):
        pass

    class S3DestinationConfiguration(Mapping):
        pass

    class ExtendedS3DestinationConfiguration(Mapping):
        pass

    class RedshiftDestinationConfiguration(Mapping):
        pass

    class ElasticsearchDestinationConfiguration(Mapping):
        pass

    class SplunkDestinationConfiguration(Mapping):
        pass

    class Tag(Mapping):
        pass

    class DeleteDeliveryStreamInput(Mapping):
        pass

    class DeleteDeliveryStreamOutput(Mapping):
        pass

    class DescribeDeliveryStreamInput(Mapping):
        pass

    class DescribeDeliveryStreamOutput(Mapping):
        pass

    class ListDeliveryStreamsInput(Mapping):
        pass

    class ListDeliveryStreamsOutput(Mapping):
        pass

    class ListTagsForDeliveryStreamInput(Mapping):
        pass

    class ListTagsForDeliveryStreamOutput(Mapping):
        pass

    class PutRecordInput(Mapping):
        pass

    class PutRecordOutput(Mapping):
        pass

    class Record(Mapping):
        pass

    class PutRecordBatchInput(Mapping):
        pass

    class PutRecordBatchOutput(Mapping):
        pass

    class StartDeliveryStreamEncryptionInput(Mapping):
        pass

    class StartDeliveryStreamEncryptionOutput(Mapping):
        pass

    class StopDeliveryStreamEncryptionInput(Mapping):
        pass

    class StopDeliveryStreamEncryptionOutput(Mapping):
        pass

    class TagDeliveryStreamInput(Mapping):
        pass

    class TagDeliveryStreamOutput(Mapping):
        pass

    class UntagDeliveryStreamInput(Mapping):
        pass

    class UntagDeliveryStreamOutput(Mapping):
        pass

    class TagKey(object):
        pass

    class UpdateDestinationInput(Mapping):
        pass

    class UpdateDestinationOutput(Mapping):
        pass

    class S3DestinationUpdate(Mapping):
        pass

    class ExtendedS3DestinationUpdate(Mapping):
        pass

    class RedshiftDestinationUpdate(Mapping):
        pass

    class ElasticsearchDestinationUpdate(Mapping):
        pass

    class SplunkDestinationUpdate(Mapping):
        pass

    def create_delivery_stream(self, DeliveryStreamName: str, DeliveryStreamType: str=None, KinesisStreamSourceConfiguration: KinesisStreamSourceConfiguration=None, S3DestinationConfiguration: S3DestinationConfiguration=None, ExtendedS3DestinationConfiguration: ExtendedS3DestinationConfiguration=None, RedshiftDestinationConfiguration: RedshiftDestinationConfiguration=None, ElasticsearchDestinationConfiguration: ElasticsearchDestinationConfiguration=None, SplunkDestinationConfiguration: SplunkDestinationConfiguration=None, Tags: List[Tag]=None) -> CreateDeliveryStreamOutput:
        pass

    def delete_delivery_stream(self, DeliveryStreamName: str) -> DeleteDeliveryStreamOutput:
        pass

    def describe_delivery_stream(self, DeliveryStreamName: str, Limit: int=None, ExclusiveStartDestinationId: str=None) -> DescribeDeliveryStreamOutput:
        pass

    def list_delivery_streams(self, Limit: int=None, DeliveryStreamType: str=None, ExclusiveStartDeliveryStreamName: str=None) -> ListDeliveryStreamsOutput:
        pass

    def list_tags_for_delivery_stream(self, DeliveryStreamName: str, ExclusiveStartTagKey: str=None, Limit: int=None) -> ListTagsForDeliveryStreamOutput:
        pass

    def put_record(self, Record: Record, DeliveryStreamName: str) -> PutRecordOutput:
        pass

    def put_record_batch(self, Records: List[Record], DeliveryStreamName: str) -> PutRecordBatchOutput:
        pass

    def start_delivery_stream_encryption(self, DeliveryStreamName: str) -> StartDeliveryStreamEncryptionOutput:
        pass

    def stop_delivery_stream_encryption(self, DeliveryStreamName: str) -> StopDeliveryStreamEncryptionOutput:
        pass

    def tag_delivery_stream(self, Tags: List[Tag], DeliveryStreamName: str) -> TagDeliveryStreamOutput:
        pass

    def untag_delivery_stream(self, TagKeys: List[TagKey], DeliveryStreamName: str) -> UntagDeliveryStreamOutput:
        pass

    def update_destination(self, DestinationId: str, CurrentDeliveryStreamVersionId: str, DeliveryStreamName: str, S3DestinationUpdate: S3DestinationUpdate=None, ExtendedS3DestinationUpdate: ExtendedS3DestinationUpdate=None, RedshiftDestinationUpdate: RedshiftDestinationUpdate=None, ElasticsearchDestinationUpdate: ElasticsearchDestinationUpdate=None, SplunkDestinationUpdate: SplunkDestinationUpdate=None) -> UpdateDestinationOutput:
        pass


class FMS(BaseClient):
    class AssociateAdminAccountRequest(Mapping):
        pass

    class DeleteNotificationChannelRequest(Mapping):
        pass

    class DeletePolicyRequest(Mapping):
        pass

    class Boolean(object):
        pass

    class DisassociateAdminAccountRequest(Mapping):
        pass

    class GetAdminAccountRequest(Mapping):
        pass

    class GetAdminAccountResponse(Mapping):
        pass

    class GetComplianceDetailRequest(Mapping):
        pass

    class GetComplianceDetailResponse(Mapping):
        pass

    class GetNotificationChannelRequest(Mapping):
        pass

    class GetNotificationChannelResponse(Mapping):
        pass

    class GetPolicyRequest(Mapping):
        pass

    class GetPolicyResponse(Mapping):
        pass

    class ListComplianceStatusRequest(Mapping):
        pass

    class ListComplianceStatusResponse(Mapping):
        pass

    class ListMemberAccountsRequest(Mapping):
        pass

    class ListMemberAccountsResponse(Mapping):
        pass

    class ListPoliciesRequest(Mapping):
        pass

    class ListPoliciesResponse(Mapping):
        pass

    class PutNotificationChannelRequest(Mapping):
        pass

    class PutPolicyRequest(Mapping):
        pass

    class PutPolicyResponse(Mapping):
        pass

    class Policy(Mapping):
        pass

    def associate_admin_account(self, AdminAccount: str):
        pass

    def delete_notification_channel(self):
        pass

    def delete_policy(self, PolicyId: str, DeleteAllPolicyResources: Boolean=None):
        pass

    def disassociate_admin_account(self):
        pass

    def get_admin_account(self) -> GetAdminAccountResponse:
        pass

    def get_compliance_detail(self, MemberAccount: str, PolicyId: str) -> GetComplianceDetailResponse:
        pass

    def get_notification_channel(self) -> GetNotificationChannelResponse:
        pass

    def get_policy(self, PolicyId: str) -> GetPolicyResponse:
        pass

    def list_compliance_status(self, PolicyId: str, NextToken: str=None, MaxResults: int=None) -> ListComplianceStatusResponse:
        pass

    def list_member_accounts(self, NextToken: str=None, MaxResults: int=None) -> ListMemberAccountsResponse:
        pass

    def list_policies(self, NextToken: str=None, MaxResults: int=None) -> ListPoliciesResponse:
        pass

    def put_notification_channel(self, SnsRoleName: str, SnsTopicArn: str):
        pass

    def put_policy(self, Policy: Policy) -> PutPolicyResponse:
        pass


class FSx(BaseClient):
    class CreateBackupRequest(Mapping):
        pass

    class CreateBackupResponse(Mapping):
        pass

    class Tag(Mapping):
        pass

    class CreateFileSystemRequest(Mapping):
        pass

    class CreateFileSystemResponse(Mapping):
        pass

    class SubnetId(object):
        pass

    class SecurityGroupId(object):
        pass

    class CreateFileSystemWindowsConfiguration(Mapping):
        pass

    class CreateFileSystemLustreConfiguration(Mapping):
        pass

    class CreateFileSystemFromBackupRequest(Mapping):
        pass

    class CreateFileSystemFromBackupResponse(Mapping):
        pass

    class DeleteBackupRequest(Mapping):
        pass

    class DeleteBackupResponse(Mapping):
        pass

    class DeleteFileSystemRequest(Mapping):
        pass

    class DeleteFileSystemResponse(Mapping):
        pass

    class DeleteFileSystemWindowsConfiguration(Mapping):
        pass

    class DescribeBackupsRequest(Mapping):
        pass

    class DescribeBackupsResponse(Mapping):
        pass

    class BackupId(object):
        pass

    class Filter(Mapping):
        pass

    class DescribeFileSystemsRequest(Mapping):
        pass

    class DescribeFileSystemsResponse(Mapping):
        pass

    class FileSystemId(object):
        pass

    class ListTagsForResourceRequest(Mapping):
        pass

    class ListTagsForResourceResponse(Mapping):
        pass

    class TagResourceRequest(Mapping):
        pass

    class TagResourceResponse(Mapping):
        pass

    class UntagResourceRequest(Mapping):
        pass

    class UntagResourceResponse(Mapping):
        pass

    class TagKey(object):
        pass

    class UpdateFileSystemRequest(Mapping):
        pass

    class UpdateFileSystemResponse(Mapping):
        pass

    class UpdateFileSystemWindowsConfiguration(Mapping):
        pass

    class UpdateFileSystemLustreConfiguration(Mapping):
        pass

    def create_backup(self, FileSystemId: str, ClientRequestToken: str=None, Tags: List[Tag]=None) -> CreateBackupResponse:
        pass

    def create_file_system(self, SubnetIds: List[SubnetId], StorageCapacity: int, FileSystemType: str, ClientRequestToken: str=None, SecurityGroupIds: List[SecurityGroupId]=None, Tags: List[Tag]=None, KmsKeyId: str=None, WindowsConfiguration: CreateFileSystemWindowsConfiguration=None, LustreConfiguration: CreateFileSystemLustreConfiguration=None) -> CreateFileSystemResponse:
        pass

    def create_file_system_from_backup(self, SubnetIds: List[SubnetId], BackupId: str, ClientRequestToken: str=None, SecurityGroupIds: List[SecurityGroupId]=None, Tags: List[Tag]=None, WindowsConfiguration: CreateFileSystemWindowsConfiguration=None) -> CreateFileSystemFromBackupResponse:
        pass

    def delete_backup(self, BackupId: str, ClientRequestToken: str=None) -> DeleteBackupResponse:
        pass

    def delete_file_system(self, FileSystemId: str, ClientRequestToken: str=None, WindowsConfiguration: DeleteFileSystemWindowsConfiguration=None) -> DeleteFileSystemResponse:
        pass

    def describe_backups(self, BackupIds: List[BackupId]=None, Filters: List[Filter]=None, MaxResults: int=None, NextToken: str=None) -> DescribeBackupsResponse:
        pass

    def describe_file_systems(self, FileSystemIds: List[FileSystemId]=None, MaxResults: int=None, NextToken: str=None) -> DescribeFileSystemsResponse:
        pass

    def list_tags_for_resource(self, ResourceARN: str, MaxResults: int=None, NextToken: str=None) -> ListTagsForResourceResponse:
        pass

    def tag_resource(self, Tags: List[Tag], ResourceARN: str) -> TagResourceResponse:
        pass

    def untag_resource(self, TagKeys: List[TagKey], ResourceARN: str) -> UntagResourceResponse:
        pass

    def update_file_system(self, FileSystemId: str, ClientRequestToken: str=None, WindowsConfiguration: UpdateFileSystemWindowsConfiguration=None, LustreConfiguration: UpdateFileSystemLustreConfiguration=None) -> UpdateFileSystemResponse:
        pass


class GameLift(BaseClient):
    class AcceptMatchInput(Mapping):
        pass

    class AcceptMatchOutput(Mapping):
        pass

    class NonZeroAndMaxString(object):
        pass

    class CreateAliasInput(Mapping):
        pass

    class CreateAliasOutput(Mapping):
        pass

    class RoutingStrategy(Mapping):
        pass

    class CreateBuildInput(Mapping):
        pass

    class CreateBuildOutput(Mapping):
        pass

    class S3Location(Mapping):
        pass

    class CreateFleetInput(Mapping):
        pass

    class CreateFleetOutput(Mapping):
        pass

    class IpPermission(Mapping):
        pass

    class RuntimeConfiguration(Mapping):
        pass

    class ResourceCreationLimitPolicy(Mapping):
        pass

    class MetricGroup(object):
        pass

    class CreateGameSessionInput(Mapping):
        pass

    class CreateGameSessionOutput(Mapping):
        pass

    class GameProperty(Mapping):
        pass

    class CreateGameSessionQueueInput(Mapping):
        pass

    class CreateGameSessionQueueOutput(Mapping):
        pass

    class PlayerLatencyPolicy(Mapping):
        pass

    class GameSessionQueueDestination(Mapping):
        pass

    class CreateMatchmakingConfigurationInput(Mapping):
        pass

    class CreateMatchmakingConfigurationOutput(Mapping):
        pass

    class ArnStringModel(object):
        pass

    class BooleanModel(object):
        pass

    class CreateMatchmakingRuleSetInput(Mapping):
        pass

    class CreateMatchmakingRuleSetOutput(Mapping):
        pass

    class CreatePlayerSessionInput(Mapping):
        pass

    class CreatePlayerSessionOutput(Mapping):
        pass

    class CreatePlayerSessionsInput(Mapping):
        pass

    class CreatePlayerSessionsOutput(Mapping):
        pass

    class PlayerDataMap(object):
        pass

    class CreateVpcPeeringAuthorizationInput(Mapping):
        pass

    class CreateVpcPeeringAuthorizationOutput(Mapping):
        pass

    class CreateVpcPeeringConnectionInput(Mapping):
        pass

    class CreateVpcPeeringConnectionOutput(Mapping):
        pass

    class DeleteAliasInput(Mapping):
        pass

    class DeleteBuildInput(Mapping):
        pass

    class DeleteFleetInput(Mapping):
        pass

    class DeleteGameSessionQueueInput(Mapping):
        pass

    class DeleteGameSessionQueueOutput(Mapping):
        pass

    class DeleteMatchmakingConfigurationInput(Mapping):
        pass

    class DeleteMatchmakingConfigurationOutput(Mapping):
        pass

    class DeleteScalingPolicyInput(Mapping):
        pass

    class DeleteVpcPeeringAuthorizationInput(Mapping):
        pass

    class DeleteVpcPeeringAuthorizationOutput(Mapping):
        pass

    class DeleteVpcPeeringConnectionInput(Mapping):
        pass

    class DeleteVpcPeeringConnectionOutput(Mapping):
        pass

    class DescribeAliasInput(Mapping):
        pass

    class DescribeAliasOutput(Mapping):
        pass

    class DescribeBuildInput(Mapping):
        pass

    class DescribeBuildOutput(Mapping):
        pass

    class DescribeEC2InstanceLimitsInput(Mapping):
        pass

    class DescribeEC2InstanceLimitsOutput(Mapping):
        pass

    class DescribeFleetAttributesInput(Mapping):
        pass

    class DescribeFleetAttributesOutput(Mapping):
        pass

    class FleetId(object):
        pass

    class DescribeFleetCapacityInput(Mapping):
        pass

    class DescribeFleetCapacityOutput(Mapping):
        pass

    class DescribeFleetEventsInput(Mapping):
        pass

    class DescribeFleetEventsOutput(Mapping):
        pass

    class Timestamp(object):
        pass

    class DescribeFleetPortSettingsInput(Mapping):
        pass

    class DescribeFleetPortSettingsOutput(Mapping):
        pass

    class DescribeFleetUtilizationInput(Mapping):
        pass

    class DescribeFleetUtilizationOutput(Mapping):
        pass

    class DescribeGameSessionDetailsInput(Mapping):
        pass

    class DescribeGameSessionDetailsOutput(Mapping):
        pass

    class DescribeGameSessionPlacementInput(Mapping):
        pass

    class DescribeGameSessionPlacementOutput(Mapping):
        pass

    class DescribeGameSessionQueuesInput(Mapping):
        pass

    class DescribeGameSessionQueuesOutput(Mapping):
        pass

    class GameSessionQueueName(object):
        pass

    class DescribeGameSessionsInput(Mapping):
        pass

    class DescribeGameSessionsOutput(Mapping):
        pass

    class DescribeInstancesInput(Mapping):
        pass

    class DescribeInstancesOutput(Mapping):
        pass

    class DescribeMatchmakingInput(Mapping):
        pass

    class DescribeMatchmakingOutput(Mapping):
        pass

    class MatchmakingIdStringModel(object):
        pass

    class DescribeMatchmakingConfigurationsInput(Mapping):
        pass

    class DescribeMatchmakingConfigurationsOutput(Mapping):
        pass

    class DescribeMatchmakingRuleSetsInput(Mapping):
        pass

    class DescribeMatchmakingRuleSetsOutput(Mapping):
        pass

    class DescribePlayerSessionsInput(Mapping):
        pass

    class DescribePlayerSessionsOutput(Mapping):
        pass

    class DescribeRuntimeConfigurationInput(Mapping):
        pass

    class DescribeRuntimeConfigurationOutput(Mapping):
        pass

    class DescribeScalingPoliciesInput(Mapping):
        pass

    class DescribeScalingPoliciesOutput(Mapping):
        pass

    class DescribeVpcPeeringAuthorizationsInput(Mapping):
        pass

    class DescribeVpcPeeringAuthorizationsOutput(Mapping):
        pass

    class DescribeVpcPeeringConnectionsInput(Mapping):
        pass

    class DescribeVpcPeeringConnectionsOutput(Mapping):
        pass

    class GetGameSessionLogUrlInput(Mapping):
        pass

    class GetGameSessionLogUrlOutput(Mapping):
        pass

    class GetInstanceAccessInput(Mapping):
        pass

    class GetInstanceAccessOutput(Mapping):
        pass

    class ListAliasesInput(Mapping):
        pass

    class ListAliasesOutput(Mapping):
        pass

    class ListBuildsInput(Mapping):
        pass

    class ListBuildsOutput(Mapping):
        pass

    class ListFleetsInput(Mapping):
        pass

    class ListFleetsOutput(Mapping):
        pass

    class PutScalingPolicyInput(Mapping):
        pass

    class PutScalingPolicyOutput(Mapping):
        pass

    class Double(object):
        pass

    class TargetConfiguration(Mapping):
        pass

    class RequestUploadCredentialsInput(Mapping):
        pass

    class RequestUploadCredentialsOutput(Mapping):
        pass

    class ResolveAliasInput(Mapping):
        pass

    class ResolveAliasOutput(Mapping):
        pass

    class SearchGameSessionsInput(Mapping):
        pass

    class SearchGameSessionsOutput(Mapping):
        pass

    class StartFleetActionsInput(Mapping):
        pass

    class StartFleetActionsOutput(Mapping):
        pass

    class FleetAction(object):
        pass

    class StartGameSessionPlacementInput(Mapping):
        pass

    class StartGameSessionPlacementOutput(Mapping):
        pass

    class PlayerLatency(Mapping):
        pass

    class DesiredPlayerSession(Mapping):
        pass

    class StartMatchBackfillInput(Mapping):
        pass

    class StartMatchBackfillOutput(Mapping):
        pass

    class Player(Mapping):
        pass

    class StartMatchmakingInput(Mapping):
        pass

    class StartMatchmakingOutput(Mapping):
        pass

    class StopFleetActionsInput(Mapping):
        pass

    class StopFleetActionsOutput(Mapping):
        pass

    class StopGameSessionPlacementInput(Mapping):
        pass

    class StopGameSessionPlacementOutput(Mapping):
        pass

    class StopMatchmakingInput(Mapping):
        pass

    class StopMatchmakingOutput(Mapping):
        pass

    class UpdateAliasInput(Mapping):
        pass

    class UpdateAliasOutput(Mapping):
        pass

    class UpdateBuildInput(Mapping):
        pass

    class UpdateBuildOutput(Mapping):
        pass

    class UpdateFleetAttributesInput(Mapping):
        pass

    class UpdateFleetAttributesOutput(Mapping):
        pass

    class UpdateFleetCapacityInput(Mapping):
        pass

    class UpdateFleetCapacityOutput(Mapping):
        pass

    class UpdateFleetPortSettingsInput(Mapping):
        pass

    class UpdateFleetPortSettingsOutput(Mapping):
        pass

    class UpdateGameSessionInput(Mapping):
        pass

    class UpdateGameSessionOutput(Mapping):
        pass

    class UpdateGameSessionQueueInput(Mapping):
        pass

    class UpdateGameSessionQueueOutput(Mapping):
        pass

    class UpdateMatchmakingConfigurationInput(Mapping):
        pass

    class UpdateMatchmakingConfigurationOutput(Mapping):
        pass

    class UpdateRuntimeConfigurationInput(Mapping):
        pass

    class UpdateRuntimeConfigurationOutput(Mapping):
        pass

    class ValidateMatchmakingRuleSetInput(Mapping):
        pass

    class ValidateMatchmakingRuleSetOutput(Mapping):
        pass

    def accept_match(self, AcceptanceType: str, PlayerIds: List[NonZeroAndMaxString], TicketId: str) -> AcceptMatchOutput:
        pass

    def create_alias(self, RoutingStrategy: RoutingStrategy, Name: str, Description: str=None) -> CreateAliasOutput:
        pass

    def create_build(self, Name: str=None, Version: str=None, StorageLocation: S3Location=None, OperatingSystem: str=None) -> CreateBuildOutput:
        pass

    def create_fleet(self, EC2InstanceType: str, BuildId: str, Name: str, Description: str=None, ServerLaunchPath: str=None, ServerLaunchParameters: str=None, LogPaths: List[NonZeroAndMaxString]=None, EC2InboundPermissions: List[IpPermission]=None, NewGameSessionProtectionPolicy: str=None, RuntimeConfiguration: RuntimeConfiguration=None, ResourceCreationLimitPolicy: ResourceCreationLimitPolicy=None, MetricGroups: List[MetricGroup]=None, PeerVpcAwsAccountId: str=None, PeerVpcId: str=None, FleetType: str=None) -> CreateFleetOutput:
        pass

    def create_game_session(self, MaximumPlayerSessionCount: int, FleetId: str=None, AliasId: str=None, Name: str=None, GameProperties: List[GameProperty]=None, CreatorId: str=None, GameSessionId: str=None, IdempotencyToken: str=None, GameSessionData: str=None) -> CreateGameSessionOutput:
        pass

    def create_game_session_queue(self, Name: str, TimeoutInSeconds: int=None, PlayerLatencyPolicies: List[PlayerLatencyPolicy]=None, Destinations: List[GameSessionQueueDestination]=None) -> CreateGameSessionQueueOutput:
        pass

    def create_matchmaking_configuration(self, RuleSetName: str, AcceptanceRequired: BooleanModel, RequestTimeoutSeconds: int, GameSessionQueueArns: List[ArnStringModel], Name: str, Description: str=None, AcceptanceTimeoutSeconds: int=None, NotificationTarget: str=None, AdditionalPlayerCount: int=None, CustomEventData: str=None, GameProperties: List[GameProperty]=None, GameSessionData: str=None) -> CreateMatchmakingConfigurationOutput:
        pass

    def create_matchmaking_rule_set(self, RuleSetBody: str, Name: str) -> CreateMatchmakingRuleSetOutput:
        pass

    def create_player_session(self, PlayerId: str, GameSessionId: str, PlayerData: str=None) -> CreatePlayerSessionOutput:
        pass

    def create_player_sessions(self, PlayerIds: List[NonZeroAndMaxString], GameSessionId: str, PlayerDataMap: PlayerDataMap=None) -> CreatePlayerSessionsOutput:
        pass

    def create_vpc_peering_authorization(self, PeerVpcId: str, GameLiftAwsAccountId: str) -> CreateVpcPeeringAuthorizationOutput:
        pass

    def create_vpc_peering_connection(self, PeerVpcId: str, PeerVpcAwsAccountId: str, FleetId: str) -> CreateVpcPeeringConnectionOutput:
        pass

    def delete_alias(self, AliasId: str):
        pass

    def delete_build(self, BuildId: str):
        pass

    def delete_fleet(self, FleetId: str):
        pass

    def delete_game_session_queue(self, Name: str) -> DeleteGameSessionQueueOutput:
        pass

    def delete_matchmaking_configuration(self, Name: str) -> DeleteMatchmakingConfigurationOutput:
        pass

    def delete_scaling_policy(self, FleetId: str, Name: str):
        pass

    def delete_vpc_peering_authorization(self, PeerVpcId: str, GameLiftAwsAccountId: str) -> DeleteVpcPeeringAuthorizationOutput:
        pass

    def delete_vpc_peering_connection(self, VpcPeeringConnectionId: str, FleetId: str) -> DeleteVpcPeeringConnectionOutput:
        pass

    def describe_alias(self, AliasId: str) -> DescribeAliasOutput:
        pass

    def describe_build(self, BuildId: str) -> DescribeBuildOutput:
        pass

    def describe_ec2_instance_limits(self, EC2InstanceType: str=None) -> DescribeEC2InstanceLimitsOutput:
        pass

    def describe_fleet_attributes(self, FleetIds: List[FleetId]=None, Limit: int=None, NextToken: str=None) -> DescribeFleetAttributesOutput:
        pass

    def describe_fleet_capacity(self, FleetIds: List[FleetId]=None, Limit: int=None, NextToken: str=None) -> DescribeFleetCapacityOutput:
        pass

    def describe_fleet_events(self, FleetId: str, StartTime: Timestamp=None, EndTime: Timestamp=None, Limit: int=None, NextToken: str=None) -> DescribeFleetEventsOutput:
        pass

    def describe_fleet_port_settings(self, FleetId: str) -> DescribeFleetPortSettingsOutput:
        pass

    def describe_fleet_utilization(self, FleetIds: List[FleetId]=None, Limit: int=None, NextToken: str=None) -> DescribeFleetUtilizationOutput:
        pass

    def describe_game_session_details(self, FleetId: str=None, GameSessionId: str=None, AliasId: str=None, StatusFilter: str=None, Limit: int=None, NextToken: str=None) -> DescribeGameSessionDetailsOutput:
        pass

    def describe_game_session_placement(self, PlacementId: str) -> DescribeGameSessionPlacementOutput:
        pass

    def describe_game_session_queues(self, Names: List[GameSessionQueueName]=None, Limit: int=None, NextToken: str=None) -> DescribeGameSessionQueuesOutput:
        pass

    def describe_game_sessions(self, FleetId: str=None, GameSessionId: str=None, AliasId: str=None, StatusFilter: str=None, Limit: int=None, NextToken: str=None) -> DescribeGameSessionsOutput:
        pass

    def describe_instances(self, FleetId: str, InstanceId: str=None, Limit: int=None, NextToken: str=None) -> DescribeInstancesOutput:
        pass

    def describe_matchmaking(self, TicketIds: List[MatchmakingIdStringModel]) -> DescribeMatchmakingOutput:
        pass

    def describe_matchmaking_configurations(self, Names: List[MatchmakingIdStringModel]=None, RuleSetName: str=None, Limit: int=None, NextToken: str=None) -> DescribeMatchmakingConfigurationsOutput:
        pass

    def describe_matchmaking_rule_sets(self, Names: List[MatchmakingIdStringModel]=None, Limit: int=None, NextToken: str=None) -> DescribeMatchmakingRuleSetsOutput:
        pass

    def describe_player_sessions(self, GameSessionId: str=None, PlayerId: str=None, PlayerSessionId: str=None, PlayerSessionStatusFilter: str=None, Limit: int=None, NextToken: str=None) -> DescribePlayerSessionsOutput:
        pass

    def describe_runtime_configuration(self, FleetId: str) -> DescribeRuntimeConfigurationOutput:
        pass

    def describe_scaling_policies(self, FleetId: str, StatusFilter: str=None, Limit: int=None, NextToken: str=None) -> DescribeScalingPoliciesOutput:
        pass

    def describe_vpc_peering_authorizations(self) -> DescribeVpcPeeringAuthorizationsOutput:
        pass

    def describe_vpc_peering_connections(self, FleetId: str=None) -> DescribeVpcPeeringConnectionsOutput:
        pass

    def get_game_session_log_url(self, GameSessionId: str) -> GetGameSessionLogUrlOutput:
        pass

    def get_instance_access(self, InstanceId: str, FleetId: str) -> GetInstanceAccessOutput:
        pass

    def list_aliases(self, RoutingStrategyType: str=None, Name: str=None, Limit: int=None, NextToken: str=None) -> ListAliasesOutput:
        pass

    def list_builds(self, Status: str=None, Limit: int=None, NextToken: str=None) -> ListBuildsOutput:
        pass

    def list_fleets(self, BuildId: str=None, Limit: int=None, NextToken: str=None) -> ListFleetsOutput:
        pass

    def put_scaling_policy(self, MetricName: str, FleetId: str, Name: str, ScalingAdjustment: int=None, ScalingAdjustmentType: str=None, Threshold: Double=None, ComparisonOperator: str=None, EvaluationPeriods: int=None, PolicyType: str=None, TargetConfiguration: TargetConfiguration=None) -> PutScalingPolicyOutput:
        pass

    def request_upload_credentials(self, BuildId: str) -> RequestUploadCredentialsOutput:
        pass

    def resolve_alias(self, AliasId: str) -> ResolveAliasOutput:
        pass

    def search_game_sessions(self, FleetId: str=None, AliasId: str=None, FilterExpression: str=None, SortExpression: str=None, Limit: int=None, NextToken: str=None) -> SearchGameSessionsOutput:
        pass

    def start_fleet_actions(self, Actions: List[FleetAction], FleetId: str) -> StartFleetActionsOutput:
        pass

    def start_game_session_placement(self, MaximumPlayerSessionCount: int, GameSessionQueueName: str, PlacementId: str, GameProperties: List[GameProperty]=None, GameSessionName: str=None, PlayerLatencies: List[PlayerLatency]=None, DesiredPlayerSessions: List[DesiredPlayerSession]=None, GameSessionData: str=None) -> StartGameSessionPlacementOutput:
        pass

    def start_match_backfill(self, Players: List[Player], GameSessionArn: str, ConfigurationName: str, TicketId: str=None) -> StartMatchBackfillOutput:
        pass

    def start_matchmaking(self, Players: List[Player], ConfigurationName: str, TicketId: str=None) -> StartMatchmakingOutput:
        pass

    def stop_fleet_actions(self, Actions: List[FleetAction], FleetId: str) -> StopFleetActionsOutput:
        pass

    def stop_game_session_placement(self, PlacementId: str) -> StopGameSessionPlacementOutput:
        pass

    def stop_matchmaking(self, TicketId: str) -> StopMatchmakingOutput:
        pass

    def update_alias(self, AliasId: str, Name: str=None, Description: str=None, RoutingStrategy: RoutingStrategy=None) -> UpdateAliasOutput:
        pass

    def update_build(self, BuildId: str, Name: str=None, Version: str=None) -> UpdateBuildOutput:
        pass

    def update_fleet_attributes(self, FleetId: str, Name: str=None, Description: str=None, NewGameSessionProtectionPolicy: str=None, ResourceCreationLimitPolicy: ResourceCreationLimitPolicy=None, MetricGroups: List[MetricGroup]=None) -> UpdateFleetAttributesOutput:
        pass

    def update_fleet_capacity(self, FleetId: str, DesiredInstances: int=None, MinSize: int=None, MaxSize: int=None) -> UpdateFleetCapacityOutput:
        pass

    def update_fleet_port_settings(self, FleetId: str, InboundPermissionAuthorizations: List[IpPermission]=None, InboundPermissionRevocations: List[IpPermission]=None) -> UpdateFleetPortSettingsOutput:
        pass

    def update_game_session(self, GameSessionId: str, MaximumPlayerSessionCount: int=None, Name: str=None, PlayerSessionCreationPolicy: str=None, ProtectionPolicy: str=None) -> UpdateGameSessionOutput:
        pass

    def update_game_session_queue(self, Name: str, TimeoutInSeconds: int=None, PlayerLatencyPolicies: List[PlayerLatencyPolicy]=None, Destinations: List[GameSessionQueueDestination]=None) -> UpdateGameSessionQueueOutput:
        pass

    def update_matchmaking_configuration(self, Name: str, Description: str=None, GameSessionQueueArns: List[ArnStringModel]=None, RequestTimeoutSeconds: int=None, AcceptanceTimeoutSeconds: int=None, AcceptanceRequired: BooleanModel=None, RuleSetName: str=None, NotificationTarget: str=None, AdditionalPlayerCount: int=None, CustomEventData: str=None, GameProperties: List[GameProperty]=None, GameSessionData: str=None) -> UpdateMatchmakingConfigurationOutput:
        pass

    def update_runtime_configuration(self, RuntimeConfiguration: RuntimeConfiguration, FleetId: str) -> UpdateRuntimeConfigurationOutput:
        pass

    def validate_matchmaking_rule_set(self, RuleSetBody: str) -> ValidateMatchmakingRuleSetOutput:
        pass


class Glacier(BaseClient):
    class AbortMultipartUploadInput(Mapping):
        pass

    class AbortVaultLockInput(Mapping):
        pass

    class AddTagsToVaultInput(Mapping):
        pass

    class TagMap(object):
        pass

    class CompleteMultipartUploadInput(Mapping):
        pass

    class ArchiveCreationOutput(Mapping):
        pass

    class CompleteVaultLockInput(Mapping):
        pass

    class CreateVaultInput(Mapping):
        pass

    class CreateVaultOutput(Mapping):
        pass

    class DeleteArchiveInput(Mapping):
        pass

    class DeleteVaultInput(Mapping):
        pass

    class DeleteVaultAccessPolicyInput(Mapping):
        pass

    class DeleteVaultNotificationsInput(Mapping):
        pass

    class DescribeJobInput(Mapping):
        pass

    class GlacierJobDescription(Mapping):
        pass

    class DescribeVaultInput(Mapping):
        pass

    class DescribeVaultOutput(Mapping):
        pass

    class GetDataRetrievalPolicyInput(Mapping):
        pass

    class GetDataRetrievalPolicyOutput(Mapping):
        pass

    class GetJobOutputInput(Mapping):
        pass

    class GetJobOutputOutput(Mapping):
        pass

    class GetVaultAccessPolicyInput(Mapping):
        pass

    class GetVaultAccessPolicyOutput(Mapping):
        pass

    class GetVaultLockInput(Mapping):
        pass

    class GetVaultLockOutput(Mapping):
        pass

    class GetVaultNotificationsInput(Mapping):
        pass

    class GetVaultNotificationsOutput(Mapping):
        pass

    class InitiateJobInput(Mapping):
        pass

    class InitiateJobOutput(Mapping):
        pass

    class JobParameters(Mapping):
        pass

    class InitiateMultipartUploadInput(Mapping):
        pass

    class InitiateMultipartUploadOutput(Mapping):
        pass

    class InitiateVaultLockInput(Mapping):
        pass

    class InitiateVaultLockOutput(Mapping):
        pass

    class VaultLockPolicy(Mapping):
        pass

    class ListJobsInput(Mapping):
        pass

    class ListJobsOutput(Mapping):
        pass

    class ListMultipartUploadsInput(Mapping):
        pass

    class ListMultipartUploadsOutput(Mapping):
        pass

    class ListPartsInput(Mapping):
        pass

    class ListPartsOutput(Mapping):
        pass

    class ListProvisionedCapacityInput(Mapping):
        pass

    class ListProvisionedCapacityOutput(Mapping):
        pass

    class ListTagsForVaultInput(Mapping):
        pass

    class ListTagsForVaultOutput(Mapping):
        pass

    class ListVaultsInput(Mapping):
        pass

    class ListVaultsOutput(Mapping):
        pass

    class PurchaseProvisionedCapacityInput(Mapping):
        pass

    class PurchaseProvisionedCapacityOutput(Mapping):
        pass

    class RemoveTagsFromVaultInput(Mapping):
        pass

    class string(object):
        pass

    class SetDataRetrievalPolicyInput(Mapping):
        pass

    class DataRetrievalPolicy(Mapping):
        pass

    class SetVaultAccessPolicyInput(Mapping):
        pass

    class VaultAccessPolicy(Mapping):
        pass

    class SetVaultNotificationsInput(Mapping):
        pass

    class VaultNotificationConfig(Mapping):
        pass

    class UploadArchiveInput(Mapping):
        pass

    class Stream(object):
        pass

    class UploadMultipartPartInput(Mapping):
        pass

    class UploadMultipartPartOutput(Mapping):
        pass

    def abort_multipart_upload(self, uploadId: str, vaultName: str, accountId: str):
        pass

    def abort_vault_lock(self, vaultName: str, accountId: str):
        pass

    def add_tags_to_vault(self, vaultName: str, accountId: str, Tags: TagMap=None):
        pass

    def complete_multipart_upload(self, uploadId: str, vaultName: str, accountId: str, archiveSize: str=None, checksum: str=None) -> ArchiveCreationOutput:
        pass

    def complete_vault_lock(self, lockId: str, vaultName: str, accountId: str):
        pass

    def create_vault(self, vaultName: str, accountId: str) -> CreateVaultOutput:
        pass

    def delete_archive(self, archiveId: str, vaultName: str, accountId: str):
        pass

    def delete_vault(self, vaultName: str, accountId: str):
        pass

    def delete_vault_access_policy(self, vaultName: str, accountId: str):
        pass

    def delete_vault_notifications(self, vaultName: str, accountId: str):
        pass

    def describe_job(self, jobId: str, vaultName: str, accountId: str) -> GlacierJobDescription:
        pass

    def describe_vault(self, vaultName: str, accountId: str) -> DescribeVaultOutput:
        pass

    def get_data_retrieval_policy(self, accountId: str) -> GetDataRetrievalPolicyOutput:
        pass

    def get_job_output(self, jobId: str, vaultName: str, accountId: str, range: str=None) -> GetJobOutputOutput:
        pass

    def get_vault_access_policy(self, vaultName: str, accountId: str) -> GetVaultAccessPolicyOutput:
        pass

    def get_vault_lock(self, vaultName: str, accountId: str) -> GetVaultLockOutput:
        pass

    def get_vault_notifications(self, vaultName: str, accountId: str) -> GetVaultNotificationsOutput:
        pass

    def initiate_job(self, vaultName: str, accountId: str, jobParameters: JobParameters=None) -> InitiateJobOutput:
        pass

    def initiate_multipart_upload(self, vaultName: str, accountId: str, archiveDescription: str=None, partSize: str=None) -> InitiateMultipartUploadOutput:
        pass

    def initiate_vault_lock(self, vaultName: str, accountId: str, policy: VaultLockPolicy=None) -> InitiateVaultLockOutput:
        pass

    def list_jobs(self, vaultName: str, accountId: str, limit: str=None, marker: str=None, statuscode: str=None, completed: str=None) -> ListJobsOutput:
        pass

    def list_multipart_uploads(self, vaultName: str, accountId: str, marker: str=None, limit: str=None) -> ListMultipartUploadsOutput:
        pass

    def list_parts(self, uploadId: str, vaultName: str, accountId: str, marker: str=None, limit: str=None) -> ListPartsOutput:
        pass

    def list_provisioned_capacity(self, accountId: str) -> ListProvisionedCapacityOutput:
        pass

    def list_tags_for_vault(self, vaultName: str, accountId: str) -> ListTagsForVaultOutput:
        pass

    def list_vaults(self, accountId: str, marker: str=None, limit: str=None) -> ListVaultsOutput:
        pass

    def purchase_provisioned_capacity(self, accountId: str) -> PurchaseProvisionedCapacityOutput:
        pass

    def remove_tags_from_vault(self, vaultName: str, accountId: str, TagKeys: List[string]=None):
        pass

    def set_data_retrieval_policy(self, accountId: str, Policy: DataRetrievalPolicy=None):
        pass

    def set_vault_access_policy(self, vaultName: str, accountId: str, policy: VaultAccessPolicy=None):
        pass

    def set_vault_notifications(self, vaultName: str, accountId: str, vaultNotificationConfig: VaultNotificationConfig=None):
        pass

    def upload_archive(self, accountId: str, vaultName: str, archiveDescription: str=None, checksum: str=None, body: Stream=None) -> ArchiveCreationOutput:
        pass

    def upload_multipart_part(self, uploadId: str, vaultName: str, accountId: str, checksum: str=None, range: str=None, body: Stream=None) -> UploadMultipartPartOutput:
        pass


class GlobalAccelerator(BaseClient):
    class CreateAcceleratorRequest(Mapping):
        pass

    class CreateAcceleratorResponse(Mapping):
        pass

    class GenericBoolean(object):
        pass

    class CreateEndpointGroupRequest(Mapping):
        pass

    class CreateEndpointGroupResponse(Mapping):
        pass

    class EndpointConfiguration(Mapping):
        pass

    class TrafficDialPercentage(object):
        pass

    class CreateListenerRequest(Mapping):
        pass

    class CreateListenerResponse(Mapping):
        pass

    class PortRange(Mapping):
        pass

    class DeleteAcceleratorRequest(Mapping):
        pass

    class DeleteEndpointGroupRequest(Mapping):
        pass

    class DeleteListenerRequest(Mapping):
        pass

    class DescribeAcceleratorRequest(Mapping):
        pass

    class DescribeAcceleratorResponse(Mapping):
        pass

    class DescribeAcceleratorAttributesRequest(Mapping):
        pass

    class DescribeAcceleratorAttributesResponse(Mapping):
        pass

    class DescribeEndpointGroupRequest(Mapping):
        pass

    class DescribeEndpointGroupResponse(Mapping):
        pass

    class DescribeListenerRequest(Mapping):
        pass

    class DescribeListenerResponse(Mapping):
        pass

    class ListAcceleratorsRequest(Mapping):
        pass

    class ListAcceleratorsResponse(Mapping):
        pass

    class ListEndpointGroupsRequest(Mapping):
        pass

    class ListEndpointGroupsResponse(Mapping):
        pass

    class ListListenersRequest(Mapping):
        pass

    class ListListenersResponse(Mapping):
        pass

    class UpdateAcceleratorRequest(Mapping):
        pass

    class UpdateAcceleratorResponse(Mapping):
        pass

    class UpdateAcceleratorAttributesRequest(Mapping):
        pass

    class UpdateAcceleratorAttributesResponse(Mapping):
        pass

    class UpdateEndpointGroupRequest(Mapping):
        pass

    class UpdateEndpointGroupResponse(Mapping):
        pass

    class UpdateListenerRequest(Mapping):
        pass

    class UpdateListenerResponse(Mapping):
        pass

    def create_accelerator(self, IdempotencyToken: str, Name: str, IpAddressType: str=None, Enabled: GenericBoolean=None) -> CreateAcceleratorResponse:
        pass

    def create_endpoint_group(self, IdempotencyToken: str, EndpointGroupRegion: str, ListenerArn: str, EndpointConfigurations: List[EndpointConfiguration]=None, TrafficDialPercentage: TrafficDialPercentage=None, HealthCheckPort: int=None, HealthCheckProtocol: str=None, HealthCheckPath: str=None, HealthCheckIntervalSeconds: int=None, ThresholdCount: int=None) -> CreateEndpointGroupResponse:
        pass

    def create_listener(self, IdempotencyToken: str, Protocol: str, PortRanges: List[PortRange], AcceleratorArn: str, ClientAffinity: str=None) -> CreateListenerResponse:
        pass

    def delete_accelerator(self, AcceleratorArn: str):
        pass

    def delete_endpoint_group(self, EndpointGroupArn: str):
        pass

    def delete_listener(self, ListenerArn: str):
        pass

    def describe_accelerator(self, AcceleratorArn: str) -> DescribeAcceleratorResponse:
        pass

    def describe_accelerator_attributes(self, AcceleratorArn: str=None) -> DescribeAcceleratorAttributesResponse:
        pass

    def describe_endpoint_group(self, EndpointGroupArn: str) -> DescribeEndpointGroupResponse:
        pass

    def describe_listener(self, ListenerArn: str) -> DescribeListenerResponse:
        pass

    def list_accelerators(self, MaxResults: int=None, NextToken: str=None) -> ListAcceleratorsResponse:
        pass

    def list_endpoint_groups(self, ListenerArn: str, MaxResults: int=None, NextToken: str=None) -> ListEndpointGroupsResponse:
        pass

    def list_listeners(self, AcceleratorArn: str, MaxResults: int=None, NextToken: str=None) -> ListListenersResponse:
        pass

    def update_accelerator(self, AcceleratorArn: str, Name: str=None, IpAddressType: str=None, Enabled: GenericBoolean=None) -> UpdateAcceleratorResponse:
        pass

    def update_accelerator_attributes(self, AcceleratorArn: str=None, FlowLogsEnabled: GenericBoolean=None, FlowLogsS3Bucket: str=None, FlowLogsS3Prefix: str=None) -> UpdateAcceleratorAttributesResponse:
        pass

    def update_endpoint_group(self, EndpointGroupArn: str, EndpointConfigurations: List[EndpointConfiguration]=None, TrafficDialPercentage: TrafficDialPercentage=None, HealthCheckPort: int=None, HealthCheckProtocol: str=None, HealthCheckPath: str=None, HealthCheckIntervalSeconds: int=None, ThresholdCount: int=None) -> UpdateEndpointGroupResponse:
        pass

    def update_listener(self, ListenerArn: str, PortRanges: List[PortRange]=None, Protocol: str=None, ClientAffinity: str=None) -> UpdateListenerResponse:
        pass


class Glue(BaseClient):
    class BatchCreatePartitionRequest(Mapping):
        pass

    class BatchCreatePartitionResponse(Mapping):
        pass

    class PartitionInput(Mapping):
        pass

    class BatchDeleteConnectionRequest(Mapping):
        pass

    class BatchDeleteConnectionResponse(Mapping):
        pass

    class NameString(object):
        pass

    class BatchDeletePartitionRequest(Mapping):
        pass

    class BatchDeletePartitionResponse(Mapping):
        pass

    class PartitionValueList(Mapping):
        pass

    class BatchDeleteTableRequest(Mapping):
        pass

    class BatchDeleteTableResponse(Mapping):
        pass

    class BatchDeleteTableVersionRequest(Mapping):
        pass

    class BatchDeleteTableVersionResponse(Mapping):
        pass

    class VersionString(object):
        pass

    class BatchGetPartitionRequest(Mapping):
        pass

    class BatchGetPartitionResponse(Mapping):
        pass

    class BatchStopJobRunRequest(Mapping):
        pass

    class BatchStopJobRunResponse(Mapping):
        pass

    class IdString(object):
        pass

    class CreateClassifierRequest(Mapping):
        pass

    class CreateClassifierResponse(Mapping):
        pass

    class CreateGrokClassifierRequest(Mapping):
        pass

    class CreateXMLClassifierRequest(Mapping):
        pass

    class CreateJsonClassifierRequest(Mapping):
        pass

    class CreateConnectionRequest(Mapping):
        pass

    class CreateConnectionResponse(Mapping):
        pass

    class ConnectionInput(Mapping):
        pass

    class CreateCrawlerRequest(Mapping):
        pass

    class CreateCrawlerResponse(Mapping):
        pass

    class CrawlerTargets(Mapping):
        pass

    class SchemaChangePolicy(Mapping):
        pass

    class CreateDatabaseRequest(Mapping):
        pass

    class CreateDatabaseResponse(Mapping):
        pass

    class DatabaseInput(Mapping):
        pass

    class CreateDevEndpointRequest(Mapping):
        pass

    class CreateDevEndpointResponse(Mapping):
        pass

    class GenericString(object):
        pass

    class CreateJobRequest(Mapping):
        pass

    class CreateJobResponse(Mapping):
        pass

    class ExecutionProperty(Mapping):
        pass

    class JobCommand(Mapping):
        pass

    class GenericMap(object):
        pass

    class ConnectionsList(Mapping):
        pass

    class NullableDouble(object):
        pass

    class NotificationProperty(Mapping):
        pass

    class CreatePartitionRequest(Mapping):
        pass

    class CreatePartitionResponse(Mapping):
        pass

    class CreateScriptRequest(Mapping):
        pass

    class CreateScriptResponse(Mapping):
        pass

    class CodeGenNode(Mapping):
        pass

    class CodeGenEdge(Mapping):
        pass

    class CreateSecurityConfigurationRequest(Mapping):
        pass

    class CreateSecurityConfigurationResponse(Mapping):
        pass

    class EncryptionConfiguration(Mapping):
        pass

    class CreateTableRequest(Mapping):
        pass

    class CreateTableResponse(Mapping):
        pass

    class TableInput(Mapping):
        pass

    class CreateTriggerRequest(Mapping):
        pass

    class CreateTriggerResponse(Mapping):
        pass

    class Predicate(Mapping):
        pass

    class Action(Mapping):
        pass

    class BooleanValue(object):
        pass

    class CreateUserDefinedFunctionRequest(Mapping):
        pass

    class CreateUserDefinedFunctionResponse(Mapping):
        pass

    class UserDefinedFunctionInput(Mapping):
        pass

    class DeleteClassifierRequest(Mapping):
        pass

    class DeleteClassifierResponse(Mapping):
        pass

    class DeleteConnectionRequest(Mapping):
        pass

    class DeleteConnectionResponse(Mapping):
        pass

    class DeleteCrawlerRequest(Mapping):
        pass

    class DeleteCrawlerResponse(Mapping):
        pass

    class DeleteDatabaseRequest(Mapping):
        pass

    class DeleteDatabaseResponse(Mapping):
        pass

    class DeleteDevEndpointRequest(Mapping):
        pass

    class DeleteDevEndpointResponse(Mapping):
        pass

    class DeleteJobRequest(Mapping):
        pass

    class DeleteJobResponse(Mapping):
        pass

    class DeletePartitionRequest(Mapping):
        pass

    class DeletePartitionResponse(Mapping):
        pass

    class ValueString(object):
        pass

    class DeleteResourcePolicyRequest(Mapping):
        pass

    class DeleteResourcePolicyResponse(Mapping):
        pass

    class DeleteSecurityConfigurationRequest(Mapping):
        pass

    class DeleteSecurityConfigurationResponse(Mapping):
        pass

    class DeleteTableRequest(Mapping):
        pass

    class DeleteTableResponse(Mapping):
        pass

    class DeleteTableVersionRequest(Mapping):
        pass

    class DeleteTableVersionResponse(Mapping):
        pass

    class DeleteTriggerRequest(Mapping):
        pass

    class DeleteTriggerResponse(Mapping):
        pass

    class DeleteUserDefinedFunctionRequest(Mapping):
        pass

    class DeleteUserDefinedFunctionResponse(Mapping):
        pass

    class GetCatalogImportStatusRequest(Mapping):
        pass

    class GetCatalogImportStatusResponse(Mapping):
        pass

    class GetClassifierRequest(Mapping):
        pass

    class GetClassifierResponse(Mapping):
        pass

    class GetClassifiersRequest(Mapping):
        pass

    class GetClassifiersResponse(Mapping):
        pass

    class GetConnectionRequest(Mapping):
        pass

    class GetConnectionResponse(Mapping):
        pass

    class Boolean(object):
        pass

    class GetConnectionsRequest(Mapping):
        pass

    class GetConnectionsResponse(Mapping):
        pass

    class GetConnectionsFilter(Mapping):
        pass

    class GetCrawlerRequest(Mapping):
        pass

    class GetCrawlerResponse(Mapping):
        pass

    class GetCrawlerMetricsRequest(Mapping):
        pass

    class GetCrawlerMetricsResponse(Mapping):
        pass

    class GetCrawlersRequest(Mapping):
        pass

    class GetCrawlersResponse(Mapping):
        pass

    class GetDataCatalogEncryptionSettingsRequest(Mapping):
        pass

    class GetDataCatalogEncryptionSettingsResponse(Mapping):
        pass

    class GetDatabaseRequest(Mapping):
        pass

    class GetDatabaseResponse(Mapping):
        pass

    class GetDatabasesRequest(Mapping):
        pass

    class GetDatabasesResponse(Mapping):
        pass

    class GetDataflowGraphRequest(Mapping):
        pass

    class GetDataflowGraphResponse(Mapping):
        pass

    class GetDevEndpointRequest(Mapping):
        pass

    class GetDevEndpointResponse(Mapping):
        pass

    class GetDevEndpointsRequest(Mapping):
        pass

    class GetDevEndpointsResponse(Mapping):
        pass

    class GetJobRequest(Mapping):
        pass

    class GetJobResponse(Mapping):
        pass

    class GetJobRunRequest(Mapping):
        pass

    class GetJobRunResponse(Mapping):
        pass

    class GetJobRunsRequest(Mapping):
        pass

    class GetJobRunsResponse(Mapping):
        pass

    class GetJobsRequest(Mapping):
        pass

    class GetJobsResponse(Mapping):
        pass

    class GetMappingRequest(Mapping):
        pass

    class GetMappingResponse(Mapping):
        pass

    class CatalogEntry(Mapping):
        pass

    class Location(Mapping):
        pass

    class GetPartitionRequest(Mapping):
        pass

    class GetPartitionResponse(Mapping):
        pass

    class GetPartitionsRequest(Mapping):
        pass

    class GetPartitionsResponse(Mapping):
        pass

    class Segment(Mapping):
        pass

    class GetPlanRequest(Mapping):
        pass

    class GetPlanResponse(Mapping):
        pass

    class MappingEntry(Mapping):
        pass

    class GetResourcePolicyRequest(Mapping):
        pass

    class GetResourcePolicyResponse(Mapping):
        pass

    class GetSecurityConfigurationRequest(Mapping):
        pass

    class GetSecurityConfigurationResponse(Mapping):
        pass

    class GetSecurityConfigurationsRequest(Mapping):
        pass

    class GetSecurityConfigurationsResponse(Mapping):
        pass

    class GetTableRequest(Mapping):
        pass

    class GetTableResponse(Mapping):
        pass

    class GetTableVersionRequest(Mapping):
        pass

    class GetTableVersionResponse(Mapping):
        pass

    class GetTableVersionsRequest(Mapping):
        pass

    class GetTableVersionsResponse(Mapping):
        pass

    class GetTablesRequest(Mapping):
        pass

    class GetTablesResponse(Mapping):
        pass

    class GetTriggerRequest(Mapping):
        pass

    class GetTriggerResponse(Mapping):
        pass

    class GetTriggersRequest(Mapping):
        pass

    class GetTriggersResponse(Mapping):
        pass

    class GetUserDefinedFunctionRequest(Mapping):
        pass

    class GetUserDefinedFunctionResponse(Mapping):
        pass

    class GetUserDefinedFunctionsRequest(Mapping):
        pass

    class GetUserDefinedFunctionsResponse(Mapping):
        pass

    class ImportCatalogToGlueRequest(Mapping):
        pass

    class ImportCatalogToGlueResponse(Mapping):
        pass

    class PutDataCatalogEncryptionSettingsRequest(Mapping):
        pass

    class PutDataCatalogEncryptionSettingsResponse(Mapping):
        pass

    class DataCatalogEncryptionSettings(Mapping):
        pass

    class PutResourcePolicyRequest(Mapping):
        pass

    class PutResourcePolicyResponse(Mapping):
        pass

    class ResetJobBookmarkRequest(Mapping):
        pass

    class ResetJobBookmarkResponse(Mapping):
        pass

    class StartCrawlerRequest(Mapping):
        pass

    class StartCrawlerResponse(Mapping):
        pass

    class StartCrawlerScheduleRequest(Mapping):
        pass

    class StartCrawlerScheduleResponse(Mapping):
        pass

    class StartJobRunRequest(Mapping):
        pass

    class StartJobRunResponse(Mapping):
        pass

    class StartTriggerRequest(Mapping):
        pass

    class StartTriggerResponse(Mapping):
        pass

    class StopCrawlerRequest(Mapping):
        pass

    class StopCrawlerResponse(Mapping):
        pass

    class StopCrawlerScheduleRequest(Mapping):
        pass

    class StopCrawlerScheduleResponse(Mapping):
        pass

    class StopTriggerRequest(Mapping):
        pass

    class StopTriggerResponse(Mapping):
        pass

    class UpdateClassifierRequest(Mapping):
        pass

    class UpdateClassifierResponse(Mapping):
        pass

    class UpdateGrokClassifierRequest(Mapping):
        pass

    class UpdateXMLClassifierRequest(Mapping):
        pass

    class UpdateJsonClassifierRequest(Mapping):
        pass

    class UpdateConnectionRequest(Mapping):
        pass

    class UpdateConnectionResponse(Mapping):
        pass

    class UpdateCrawlerRequest(Mapping):
        pass

    class UpdateCrawlerResponse(Mapping):
        pass

    class UpdateCrawlerScheduleRequest(Mapping):
        pass

    class UpdateCrawlerScheduleResponse(Mapping):
        pass

    class UpdateDatabaseRequest(Mapping):
        pass

    class UpdateDatabaseResponse(Mapping):
        pass

    class UpdateDevEndpointRequest(Mapping):
        pass

    class UpdateDevEndpointResponse(Mapping):
        pass

    class DevEndpointCustomLibraries(Mapping):
        pass

    class UpdateJobRequest(Mapping):
        pass

    class UpdateJobResponse(Mapping):
        pass

    class JobUpdate(Mapping):
        pass

    class UpdatePartitionRequest(Mapping):
        pass

    class UpdatePartitionResponse(Mapping):
        pass

    class UpdateTableRequest(Mapping):
        pass

    class UpdateTableResponse(Mapping):
        pass

    class BooleanNullable(object):
        pass

    class UpdateTriggerRequest(Mapping):
        pass

    class UpdateTriggerResponse(Mapping):
        pass

    class TriggerUpdate(Mapping):
        pass

    class UpdateUserDefinedFunctionRequest(Mapping):
        pass

    class UpdateUserDefinedFunctionResponse(Mapping):
        pass

    def batch_create_partition(self, PartitionInputList: List[PartitionInput], TableName: str, DatabaseName: str, CatalogId: str=None) -> BatchCreatePartitionResponse:
        pass

    def batch_delete_connection(self, ConnectionNameList: List[NameString], CatalogId: str=None) -> BatchDeleteConnectionResponse:
        pass

    def batch_delete_partition(self, PartitionsToDelete: List[PartitionValueList], TableName: str, DatabaseName: str, CatalogId: str=None) -> BatchDeletePartitionResponse:
        pass

    def batch_delete_table(self, TablesToDelete: List[NameString], DatabaseName: str, CatalogId: str=None) -> BatchDeleteTableResponse:
        pass

    def batch_delete_table_version(self, VersionIds: List[VersionString], TableName: str, DatabaseName: str, CatalogId: str=None) -> BatchDeleteTableVersionResponse:
        pass

    def batch_get_partition(self, PartitionsToGet: List[PartitionValueList], TableName: str, DatabaseName: str, CatalogId: str=None) -> BatchGetPartitionResponse:
        pass

    def batch_stop_job_run(self, JobRunIds: List[IdString], JobName: str) -> BatchStopJobRunResponse:
        pass

    def create_classifier(self, GrokClassifier: CreateGrokClassifierRequest=None, XMLClassifier: CreateXMLClassifierRequest=None, JsonClassifier: CreateJsonClassifierRequest=None) -> CreateClassifierResponse:
        pass

    def create_connection(self, ConnectionInput: ConnectionInput, CatalogId: str=None) -> CreateConnectionResponse:
        pass

    def create_crawler(self, Targets: CrawlerTargets, DatabaseName: str, Role: str, Name: str, Description: str=None, Schedule: str=None, Classifiers: List[NameString]=None, TablePrefix: str=None, SchemaChangePolicy: SchemaChangePolicy=None, Configuration: str=None, CrawlerSecurityConfiguration: str=None) -> CreateCrawlerResponse:
        pass

    def create_database(self, DatabaseInput: DatabaseInput, CatalogId: str=None) -> CreateDatabaseResponse:
        pass

    def create_dev_endpoint(self, RoleArn: str, EndpointName: str, SecurityGroupIds: List[GenericString]=None, SubnetId: str=None, PublicKey: str=None, PublicKeys: List[GenericString]=None, NumberOfNodes: int=None, ExtraPythonLibsS3Path: str=None, ExtraJarsS3Path: str=None, SecurityConfiguration: str=None) -> CreateDevEndpointResponse:
        pass

    def create_job(self, Command: JobCommand, Role: str, Name: str, Description: str=None, LogUri: str=None, ExecutionProperty: ExecutionProperty=None, DefaultArguments: GenericMap=None, Connections: ConnectionsList=None, MaxRetries: int=None, AllocatedCapacity: int=None, Timeout: int=None, MaxCapacity: NullableDouble=None, NotificationProperty: NotificationProperty=None, SecurityConfiguration: str=None) -> CreateJobResponse:
        pass

    def create_partition(self, PartitionInput: PartitionInput, TableName: str, DatabaseName: str, CatalogId: str=None) -> CreatePartitionResponse:
        pass

    def create_script(self, DagNodes: List[CodeGenNode]=None, DagEdges: List[CodeGenEdge]=None, Language: str=None) -> CreateScriptResponse:
        pass

    def create_security_configuration(self, EncryptionConfiguration: EncryptionConfiguration, Name: str) -> CreateSecurityConfigurationResponse:
        pass

    def create_table(self, TableInput: TableInput, DatabaseName: str, CatalogId: str=None) -> CreateTableResponse:
        pass

    def create_trigger(self, Actions: List[Action], Type: str, Name: str, Schedule: str=None, Predicate: Predicate=None, Description: str=None, StartOnCreation: BooleanValue=None) -> CreateTriggerResponse:
        pass

    def create_user_defined_function(self, FunctionInput: UserDefinedFunctionInput, DatabaseName: str, CatalogId: str=None) -> CreateUserDefinedFunctionResponse:
        pass

    def delete_classifier(self, Name: str) -> DeleteClassifierResponse:
        pass

    def delete_connection(self, ConnectionName: str, CatalogId: str=None) -> DeleteConnectionResponse:
        pass

    def delete_crawler(self, Name: str) -> DeleteCrawlerResponse:
        pass

    def delete_database(self, Name: str, CatalogId: str=None) -> DeleteDatabaseResponse:
        pass

    def delete_dev_endpoint(self, EndpointName: str) -> DeleteDevEndpointResponse:
        pass

    def delete_job(self, JobName: str) -> DeleteJobResponse:
        pass

    def delete_partition(self, PartitionValues: List[ValueString], TableName: str, DatabaseName: str, CatalogId: str=None) -> DeletePartitionResponse:
        pass

    def delete_resource_policy(self, PolicyHashCondition: str=None) -> DeleteResourcePolicyResponse:
        pass

    def delete_security_configuration(self, Name: str) -> DeleteSecurityConfigurationResponse:
        pass

    def delete_table(self, Name: str, DatabaseName: str, CatalogId: str=None) -> DeleteTableResponse:
        pass

    def delete_table_version(self, VersionId: str, TableName: str, DatabaseName: str, CatalogId: str=None) -> DeleteTableVersionResponse:
        pass

    def delete_trigger(self, Name: str) -> DeleteTriggerResponse:
        pass

    def delete_user_defined_function(self, FunctionName: str, DatabaseName: str, CatalogId: str=None) -> DeleteUserDefinedFunctionResponse:
        pass

    def get_catalog_import_status(self, CatalogId: str=None) -> GetCatalogImportStatusResponse:
        pass

    def get_classifier(self, Name: str) -> GetClassifierResponse:
        pass

    def get_classifiers(self, MaxResults: int=None, NextToken: str=None) -> GetClassifiersResponse:
        pass

    def get_connection(self, Name: str, CatalogId: str=None, HidePassword: Boolean=None) -> GetConnectionResponse:
        pass

    def get_connections(self, CatalogId: str=None, Filter: GetConnectionsFilter=None, HidePassword: Boolean=None, NextToken: str=None, MaxResults: int=None) -> GetConnectionsResponse:
        pass

    def get_crawler(self, Name: str) -> GetCrawlerResponse:
        pass

    def get_crawler_metrics(self, CrawlerNameList: List[NameString]=None, MaxResults: int=None, NextToken: str=None) -> GetCrawlerMetricsResponse:
        pass

    def get_crawlers(self, MaxResults: int=None, NextToken: str=None) -> GetCrawlersResponse:
        pass

    def get_data_catalog_encryption_settings(self, CatalogId: str=None) -> GetDataCatalogEncryptionSettingsResponse:
        pass

    def get_database(self, Name: str, CatalogId: str=None) -> GetDatabaseResponse:
        pass

    def get_databases(self, CatalogId: str=None, NextToken: str=None, MaxResults: int=None) -> GetDatabasesResponse:
        pass

    def get_dataflow_graph(self, PythonScript: str=None) -> GetDataflowGraphResponse:
        pass

    def get_dev_endpoint(self, EndpointName: str) -> GetDevEndpointResponse:
        pass

    def get_dev_endpoints(self, MaxResults: int=None, NextToken: str=None) -> GetDevEndpointsResponse:
        pass

    def get_job(self, JobName: str) -> GetJobResponse:
        pass

    def get_job_run(self, RunId: str, JobName: str, PredecessorsIncluded: BooleanValue=None) -> GetJobRunResponse:
        pass

    def get_job_runs(self, JobName: str, NextToken: str=None, MaxResults: int=None) -> GetJobRunsResponse:
        pass

    def get_jobs(self, NextToken: str=None, MaxResults: int=None) -> GetJobsResponse:
        pass

    def get_mapping(self, Source: CatalogEntry, Sinks: List[CatalogEntry]=None, Location: Location=None) -> GetMappingResponse:
        pass

    def get_partition(self, PartitionValues: List[ValueString], TableName: str, DatabaseName: str, CatalogId: str=None) -> GetPartitionResponse:
        pass

    def get_partitions(self, TableName: str, DatabaseName: str, CatalogId: str=None, Expression: str=None, NextToken: str=None, Segment: Segment=None, MaxResults: int=None) -> GetPartitionsResponse:
        pass

    def get_plan(self, Source: CatalogEntry, Mapping: List[MappingEntry], Sinks: List[CatalogEntry]=None, Location: Location=None, Language: str=None) -> GetPlanResponse:
        pass

    def get_resource_policy(self) -> GetResourcePolicyResponse:
        pass

    def get_security_configuration(self, Name: str) -> GetSecurityConfigurationResponse:
        pass

    def get_security_configurations(self, MaxResults: int=None, NextToken: str=None) -> GetSecurityConfigurationsResponse:
        pass

    def get_table(self, Name: str, DatabaseName: str, CatalogId: str=None) -> GetTableResponse:
        pass

    def get_table_version(self, TableName: str, DatabaseName: str, CatalogId: str=None, VersionId: str=None) -> GetTableVersionResponse:
        pass

    def get_table_versions(self, TableName: str, DatabaseName: str, CatalogId: str=None, NextToken: str=None, MaxResults: int=None) -> GetTableVersionsResponse:
        pass

    def get_tables(self, DatabaseName: str, CatalogId: str=None, Expression: str=None, NextToken: str=None, MaxResults: int=None) -> GetTablesResponse:
        pass

    def get_trigger(self, Name: str) -> GetTriggerResponse:
        pass

    def get_triggers(self, NextToken: str=None, DependentJobName: str=None, MaxResults: int=None) -> GetTriggersResponse:
        pass

    def get_user_defined_function(self, FunctionName: str, DatabaseName: str, CatalogId: str=None) -> GetUserDefinedFunctionResponse:
        pass

    def get_user_defined_functions(self, Pattern: str, DatabaseName: str, CatalogId: str=None, NextToken: str=None, MaxResults: int=None) -> GetUserDefinedFunctionsResponse:
        pass

    def import_catalog_to_glue(self, CatalogId: str=None) -> ImportCatalogToGlueResponse:
        pass

    def put_data_catalog_encryption_settings(self, DataCatalogEncryptionSettings: DataCatalogEncryptionSettings, CatalogId: str=None) -> PutDataCatalogEncryptionSettingsResponse:
        pass

    def put_resource_policy(self, PolicyInJson: str, PolicyHashCondition: str=None, PolicyExistsCondition: str=None) -> PutResourcePolicyResponse:
        pass

    def reset_job_bookmark(self, JobName: str) -> ResetJobBookmarkResponse:
        pass

    def start_crawler(self, Name: str) -> StartCrawlerResponse:
        pass

    def start_crawler_schedule(self, CrawlerName: str) -> StartCrawlerScheduleResponse:
        pass

    def start_job_run(self, JobName: str, JobRunId: str=None, Arguments: GenericMap=None, AllocatedCapacity: int=None, Timeout: int=None, MaxCapacity: NullableDouble=None, NotificationProperty: NotificationProperty=None, SecurityConfiguration: str=None) -> StartJobRunResponse:
        pass

    def start_trigger(self, Name: str) -> StartTriggerResponse:
        pass

    def stop_crawler(self, Name: str) -> StopCrawlerResponse:
        pass

    def stop_crawler_schedule(self, CrawlerName: str) -> StopCrawlerScheduleResponse:
        pass

    def stop_trigger(self, Name: str) -> StopTriggerResponse:
        pass

    def update_classifier(self, GrokClassifier: UpdateGrokClassifierRequest=None, XMLClassifier: UpdateXMLClassifierRequest=None, JsonClassifier: UpdateJsonClassifierRequest=None) -> UpdateClassifierResponse:
        pass

    def update_connection(self, ConnectionInput: ConnectionInput, Name: str, CatalogId: str=None) -> UpdateConnectionResponse:
        pass

    def update_crawler(self, Name: str, Role: str=None, DatabaseName: str=None, Description: str=None, Targets: CrawlerTargets=None, Schedule: str=None, Classifiers: List[NameString]=None, TablePrefix: str=None, SchemaChangePolicy: SchemaChangePolicy=None, Configuration: str=None, CrawlerSecurityConfiguration: str=None) -> UpdateCrawlerResponse:
        pass

    def update_crawler_schedule(self, CrawlerName: str, Schedule: str=None) -> UpdateCrawlerScheduleResponse:
        pass

    def update_database(self, DatabaseInput: DatabaseInput, Name: str, CatalogId: str=None) -> UpdateDatabaseResponse:
        pass

    def update_dev_endpoint(self, EndpointName: str, PublicKey: str=None, AddPublicKeys: List[GenericString]=None, DeletePublicKeys: List[GenericString]=None, CustomLibraries: DevEndpointCustomLibraries=None, UpdateEtlLibraries: BooleanValue=None) -> UpdateDevEndpointResponse:
        pass

    def update_job(self, JobUpdate: JobUpdate, JobName: str) -> UpdateJobResponse:
        pass

    def update_partition(self, PartitionInput: PartitionInput, PartitionValueList: List[ValueString], TableName: str, DatabaseName: str, CatalogId: str=None) -> UpdatePartitionResponse:
        pass

    def update_table(self, TableInput: TableInput, DatabaseName: str, CatalogId: str=None, SkipArchive: BooleanNullable=None) -> UpdateTableResponse:
        pass

    def update_trigger(self, TriggerUpdate: TriggerUpdate, Name: str) -> UpdateTriggerResponse:
        pass

    def update_user_defined_function(self, FunctionInput: UserDefinedFunctionInput, FunctionName: str, DatabaseName: str, CatalogId: str=None) -> UpdateUserDefinedFunctionResponse:
        pass


class Greengrass(BaseClient):
    class AssociateRoleToGroupRequest(Mapping):
        pass

    class AssociateRoleToGroupResponse(Mapping):
        pass

    class AssociateServiceRoleToAccountRequest(Mapping):
        pass

    class AssociateServiceRoleToAccountResponse(Mapping):
        pass

    class CreateConnectorDefinitionRequest(Mapping):
        pass

    class CreateConnectorDefinitionResponse(Mapping):
        pass

    class ConnectorDefinitionVersion(Mapping):
        pass

    class CreateConnectorDefinitionVersionRequest(Mapping):
        pass

    class CreateConnectorDefinitionVersionResponse(Mapping):
        pass

    class Connector(Mapping):
        pass

    class CreateCoreDefinitionRequest(Mapping):
        pass

    class CreateCoreDefinitionResponse(Mapping):
        pass

    class CoreDefinitionVersion(Mapping):
        pass

    class CreateCoreDefinitionVersionRequest(Mapping):
        pass

    class CreateCoreDefinitionVersionResponse(Mapping):
        pass

    class Core(Mapping):
        pass

    class CreateDeploymentRequest(Mapping):
        pass

    class CreateDeploymentResponse(Mapping):
        pass

    class CreateDeviceDefinitionRequest(Mapping):
        pass

    class CreateDeviceDefinitionResponse(Mapping):
        pass

    class DeviceDefinitionVersion(Mapping):
        pass

    class CreateDeviceDefinitionVersionRequest(Mapping):
        pass

    class CreateDeviceDefinitionVersionResponse(Mapping):
        pass

    class Device(Mapping):
        pass

    class CreateFunctionDefinitionRequest(Mapping):
        pass

    class CreateFunctionDefinitionResponse(Mapping):
        pass

    class FunctionDefinitionVersion(Mapping):
        pass

    class CreateFunctionDefinitionVersionRequest(Mapping):
        pass

    class CreateFunctionDefinitionVersionResponse(Mapping):
        pass

    class FunctionDefaultConfig(Mapping):
        pass

    class Function(Mapping):
        pass

    class CreateGroupRequest(Mapping):
        pass

    class CreateGroupResponse(Mapping):
        pass

    class GroupVersion(Mapping):
        pass

    class CreateGroupCertificateAuthorityRequest(Mapping):
        pass

    class CreateGroupCertificateAuthorityResponse(Mapping):
        pass

    class CreateGroupVersionRequest(Mapping):
        pass

    class CreateGroupVersionResponse(Mapping):
        pass

    class CreateLoggerDefinitionRequest(Mapping):
        pass

    class CreateLoggerDefinitionResponse(Mapping):
        pass

    class LoggerDefinitionVersion(Mapping):
        pass

    class CreateLoggerDefinitionVersionRequest(Mapping):
        pass

    class CreateLoggerDefinitionVersionResponse(Mapping):
        pass

    class Logger(Mapping):
        pass

    class CreateResourceDefinitionRequest(Mapping):
        pass

    class CreateResourceDefinitionResponse(Mapping):
        pass

    class ResourceDefinitionVersion(Mapping):
        pass

    class CreateResourceDefinitionVersionRequest(Mapping):
        pass

    class CreateResourceDefinitionVersionResponse(Mapping):
        pass

    class Resource(Mapping):
        pass

    class CreateSoftwareUpdateJobRequest(Mapping):
        pass

    class CreateSoftwareUpdateJobResponse(Mapping):
        pass

    class __string(object):
        pass

    class CreateSubscriptionDefinitionRequest(Mapping):
        pass

    class CreateSubscriptionDefinitionResponse(Mapping):
        pass

    class SubscriptionDefinitionVersion(Mapping):
        pass

    class CreateSubscriptionDefinitionVersionRequest(Mapping):
        pass

    class CreateSubscriptionDefinitionVersionResponse(Mapping):
        pass

    class Subscription(Mapping):
        pass

    class DeleteConnectorDefinitionRequest(Mapping):
        pass

    class DeleteConnectorDefinitionResponse(Mapping):
        pass

    class DeleteCoreDefinitionRequest(Mapping):
        pass

    class DeleteCoreDefinitionResponse(Mapping):
        pass

    class DeleteDeviceDefinitionRequest(Mapping):
        pass

    class DeleteDeviceDefinitionResponse(Mapping):
        pass

    class DeleteFunctionDefinitionRequest(Mapping):
        pass

    class DeleteFunctionDefinitionResponse(Mapping):
        pass

    class DeleteGroupRequest(Mapping):
        pass

    class DeleteGroupResponse(Mapping):
        pass

    class DeleteLoggerDefinitionRequest(Mapping):
        pass

    class DeleteLoggerDefinitionResponse(Mapping):
        pass

    class DeleteResourceDefinitionRequest(Mapping):
        pass

    class DeleteResourceDefinitionResponse(Mapping):
        pass

    class DeleteSubscriptionDefinitionRequest(Mapping):
        pass

    class DeleteSubscriptionDefinitionResponse(Mapping):
        pass

    class DisassociateRoleFromGroupRequest(Mapping):
        pass

    class DisassociateRoleFromGroupResponse(Mapping):
        pass

    class DisassociateServiceRoleFromAccountRequest(Mapping):
        pass

    class DisassociateServiceRoleFromAccountResponse(Mapping):
        pass

    class GetAssociatedRoleRequest(Mapping):
        pass

    class GetAssociatedRoleResponse(Mapping):
        pass

    class GetBulkDeploymentStatusRequest(Mapping):
        pass

    class GetBulkDeploymentStatusResponse(Mapping):
        pass

    class GetConnectivityInfoRequest(Mapping):
        pass

    class GetConnectivityInfoResponse(Mapping):
        pass

    class GetConnectorDefinitionRequest(Mapping):
        pass

    class GetConnectorDefinitionResponse(Mapping):
        pass

    class GetConnectorDefinitionVersionRequest(Mapping):
        pass

    class GetConnectorDefinitionVersionResponse(Mapping):
        pass

    class GetCoreDefinitionRequest(Mapping):
        pass

    class GetCoreDefinitionResponse(Mapping):
        pass

    class GetCoreDefinitionVersionRequest(Mapping):
        pass

    class GetCoreDefinitionVersionResponse(Mapping):
        pass

    class GetDeploymentStatusRequest(Mapping):
        pass

    class GetDeploymentStatusResponse(Mapping):
        pass

    class GetDeviceDefinitionRequest(Mapping):
        pass

    class GetDeviceDefinitionResponse(Mapping):
        pass

    class GetDeviceDefinitionVersionRequest(Mapping):
        pass

    class GetDeviceDefinitionVersionResponse(Mapping):
        pass

    class GetFunctionDefinitionRequest(Mapping):
        pass

    class GetFunctionDefinitionResponse(Mapping):
        pass

    class GetFunctionDefinitionVersionRequest(Mapping):
        pass

    class GetFunctionDefinitionVersionResponse(Mapping):
        pass

    class GetGroupRequest(Mapping):
        pass

    class GetGroupResponse(Mapping):
        pass

    class GetGroupCertificateAuthorityRequest(Mapping):
        pass

    class GetGroupCertificateAuthorityResponse(Mapping):
        pass

    class GetGroupCertificateConfigurationRequest(Mapping):
        pass

    class GetGroupCertificateConfigurationResponse(Mapping):
        pass

    class GetGroupVersionRequest(Mapping):
        pass

    class GetGroupVersionResponse(Mapping):
        pass

    class GetLoggerDefinitionRequest(Mapping):
        pass

    class GetLoggerDefinitionResponse(Mapping):
        pass

    class GetLoggerDefinitionVersionRequest(Mapping):
        pass

    class GetLoggerDefinitionVersionResponse(Mapping):
        pass

    class GetResourceDefinitionRequest(Mapping):
        pass

    class GetResourceDefinitionResponse(Mapping):
        pass

    class GetResourceDefinitionVersionRequest(Mapping):
        pass

    class GetResourceDefinitionVersionResponse(Mapping):
        pass

    class GetServiceRoleForAccountRequest(Mapping):
        pass

    class GetServiceRoleForAccountResponse(Mapping):
        pass

    class GetSubscriptionDefinitionRequest(Mapping):
        pass

    class GetSubscriptionDefinitionResponse(Mapping):
        pass

    class GetSubscriptionDefinitionVersionRequest(Mapping):
        pass

    class GetSubscriptionDefinitionVersionResponse(Mapping):
        pass

    class ListBulkDeploymentDetailedReportsRequest(Mapping):
        pass

    class ListBulkDeploymentDetailedReportsResponse(Mapping):
        pass

    class ListBulkDeploymentsRequest(Mapping):
        pass

    class ListBulkDeploymentsResponse(Mapping):
        pass

    class ListConnectorDefinitionVersionsRequest(Mapping):
        pass

    class ListConnectorDefinitionVersionsResponse(Mapping):
        pass

    class ListConnectorDefinitionsRequest(Mapping):
        pass

    class ListConnectorDefinitionsResponse(Mapping):
        pass

    class ListCoreDefinitionVersionsRequest(Mapping):
        pass

    class ListCoreDefinitionVersionsResponse(Mapping):
        pass

    class ListCoreDefinitionsRequest(Mapping):
        pass

    class ListCoreDefinitionsResponse(Mapping):
        pass

    class ListDeploymentsRequest(Mapping):
        pass

    class ListDeploymentsResponse(Mapping):
        pass

    class ListDeviceDefinitionVersionsRequest(Mapping):
        pass

    class ListDeviceDefinitionVersionsResponse(Mapping):
        pass

    class ListDeviceDefinitionsRequest(Mapping):
        pass

    class ListDeviceDefinitionsResponse(Mapping):
        pass

    class ListFunctionDefinitionVersionsRequest(Mapping):
        pass

    class ListFunctionDefinitionVersionsResponse(Mapping):
        pass

    class ListFunctionDefinitionsRequest(Mapping):
        pass

    class ListFunctionDefinitionsResponse(Mapping):
        pass

    class ListGroupCertificateAuthoritiesRequest(Mapping):
        pass

    class ListGroupCertificateAuthoritiesResponse(Mapping):
        pass

    class ListGroupVersionsRequest(Mapping):
        pass

    class ListGroupVersionsResponse(Mapping):
        pass

    class ListGroupsRequest(Mapping):
        pass

    class ListGroupsResponse(Mapping):
        pass

    class ListLoggerDefinitionVersionsRequest(Mapping):
        pass

    class ListLoggerDefinitionVersionsResponse(Mapping):
        pass

    class ListLoggerDefinitionsRequest(Mapping):
        pass

    class ListLoggerDefinitionsResponse(Mapping):
        pass

    class ListResourceDefinitionVersionsRequest(Mapping):
        pass

    class ListResourceDefinitionVersionsResponse(Mapping):
        pass

    class ListResourceDefinitionsRequest(Mapping):
        pass

    class ListResourceDefinitionsResponse(Mapping):
        pass

    class ListSubscriptionDefinitionVersionsRequest(Mapping):
        pass

    class ListSubscriptionDefinitionVersionsResponse(Mapping):
        pass

    class ListSubscriptionDefinitionsRequest(Mapping):
        pass

    class ListSubscriptionDefinitionsResponse(Mapping):
        pass

    class ResetDeploymentsRequest(Mapping):
        pass

    class ResetDeploymentsResponse(Mapping):
        pass

    class __boolean(object):
        pass

    class StartBulkDeploymentRequest(Mapping):
        pass

    class StartBulkDeploymentResponse(Mapping):
        pass

    class StopBulkDeploymentRequest(Mapping):
        pass

    class StopBulkDeploymentResponse(Mapping):
        pass

    class UpdateConnectivityInfoRequest(Mapping):
        pass

    class UpdateConnectivityInfoResponse(Mapping):
        pass

    class ConnectivityInfo(Mapping):
        pass

    class UpdateConnectorDefinitionRequest(Mapping):
        pass

    class UpdateConnectorDefinitionResponse(Mapping):
        pass

    class UpdateCoreDefinitionRequest(Mapping):
        pass

    class UpdateCoreDefinitionResponse(Mapping):
        pass

    class UpdateDeviceDefinitionRequest(Mapping):
        pass

    class UpdateDeviceDefinitionResponse(Mapping):
        pass

    class UpdateFunctionDefinitionRequest(Mapping):
        pass

    class UpdateFunctionDefinitionResponse(Mapping):
        pass

    class UpdateGroupRequest(Mapping):
        pass

    class UpdateGroupResponse(Mapping):
        pass

    class UpdateGroupCertificateConfigurationRequest(Mapping):
        pass

    class UpdateGroupCertificateConfigurationResponse(Mapping):
        pass

    class UpdateLoggerDefinitionRequest(Mapping):
        pass

    class UpdateLoggerDefinitionResponse(Mapping):
        pass

    class UpdateResourceDefinitionRequest(Mapping):
        pass

    class UpdateResourceDefinitionResponse(Mapping):
        pass

    class UpdateSubscriptionDefinitionRequest(Mapping):
        pass

    class UpdateSubscriptionDefinitionResponse(Mapping):
        pass

    def associate_role_to_group(self, GroupId: str, RoleArn: str=None) -> AssociateRoleToGroupResponse:
        pass

    def associate_service_role_to_account(self, RoleArn: str=None) -> AssociateServiceRoleToAccountResponse:
        pass

    def create_connector_definition(self, AmznClientToken: str=None, InitialVersion: ConnectorDefinitionVersion=None, Name: str=None) -> CreateConnectorDefinitionResponse:
        pass

    def create_connector_definition_version(self, ConnectorDefinitionId: str, AmznClientToken: str=None, Connectors: List[Connector]=None) -> CreateConnectorDefinitionVersionResponse:
        pass

    def create_core_definition(self, AmznClientToken: str=None, InitialVersion: CoreDefinitionVersion=None, Name: str=None) -> CreateCoreDefinitionResponse:
        pass

    def create_core_definition_version(self, CoreDefinitionId: str, AmznClientToken: str=None, Cores: List[Core]=None) -> CreateCoreDefinitionVersionResponse:
        pass

    def create_deployment(self, GroupId: str, AmznClientToken: str=None, DeploymentId: str=None, DeploymentType: str=None, GroupVersionId: str=None) -> CreateDeploymentResponse:
        pass

    def create_device_definition(self, AmznClientToken: str=None, InitialVersion: DeviceDefinitionVersion=None, Name: str=None) -> CreateDeviceDefinitionResponse:
        pass

    def create_device_definition_version(self, DeviceDefinitionId: str, AmznClientToken: str=None, Devices: List[Device]=None) -> CreateDeviceDefinitionVersionResponse:
        pass

    def create_function_definition(self, AmznClientToken: str=None, InitialVersion: FunctionDefinitionVersion=None, Name: str=None) -> CreateFunctionDefinitionResponse:
        pass

    def create_function_definition_version(self, FunctionDefinitionId: str, AmznClientToken: str=None, DefaultConfig: FunctionDefaultConfig=None, Functions: List[Function]=None) -> CreateFunctionDefinitionVersionResponse:
        pass

    def create_group(self, AmznClientToken: str=None, InitialVersion: GroupVersion=None, Name: str=None) -> CreateGroupResponse:
        pass

    def create_group_certificate_authority(self, GroupId: str, AmznClientToken: str=None) -> CreateGroupCertificateAuthorityResponse:
        pass

    def create_group_version(self, GroupId: str, AmznClientToken: str=None, ConnectorDefinitionVersionArn: str=None, CoreDefinitionVersionArn: str=None, DeviceDefinitionVersionArn: str=None, FunctionDefinitionVersionArn: str=None, LoggerDefinitionVersionArn: str=None, ResourceDefinitionVersionArn: str=None, SubscriptionDefinitionVersionArn: str=None) -> CreateGroupVersionResponse:
        pass

    def create_logger_definition(self, AmznClientToken: str=None, InitialVersion: LoggerDefinitionVersion=None, Name: str=None) -> CreateLoggerDefinitionResponse:
        pass

    def create_logger_definition_version(self, LoggerDefinitionId: str, AmznClientToken: str=None, Loggers: List[Logger]=None) -> CreateLoggerDefinitionVersionResponse:
        pass

    def create_resource_definition(self, AmznClientToken: str=None, InitialVersion: ResourceDefinitionVersion=None, Name: str=None) -> CreateResourceDefinitionResponse:
        pass

    def create_resource_definition_version(self, ResourceDefinitionId: str, AmznClientToken: str=None, Resources: List[Resource]=None) -> CreateResourceDefinitionVersionResponse:
        pass

    def create_software_update_job(self, AmznClientToken: str=None, S3UrlSignerRole: str=None, SoftwareToUpdate: str=None, UpdateAgentLogLevel: str=None, UpdateTargets: List[__string]=None, UpdateTargetsArchitecture: str=None, UpdateTargetsOperatingSystem: str=None) -> CreateSoftwareUpdateJobResponse:
        pass

    def create_subscription_definition(self, AmznClientToken: str=None, InitialVersion: SubscriptionDefinitionVersion=None, Name: str=None) -> CreateSubscriptionDefinitionResponse:
        pass

    def create_subscription_definition_version(self, SubscriptionDefinitionId: str, AmznClientToken: str=None, Subscriptions: List[Subscription]=None) -> CreateSubscriptionDefinitionVersionResponse:
        pass

    def delete_connector_definition(self, ConnectorDefinitionId: str) -> DeleteConnectorDefinitionResponse:
        pass

    def delete_core_definition(self, CoreDefinitionId: str) -> DeleteCoreDefinitionResponse:
        pass

    def delete_device_definition(self, DeviceDefinitionId: str) -> DeleteDeviceDefinitionResponse:
        pass

    def delete_function_definition(self, FunctionDefinitionId: str) -> DeleteFunctionDefinitionResponse:
        pass

    def delete_group(self, GroupId: str) -> DeleteGroupResponse:
        pass

    def delete_logger_definition(self, LoggerDefinitionId: str) -> DeleteLoggerDefinitionResponse:
        pass

    def delete_resource_definition(self, ResourceDefinitionId: str) -> DeleteResourceDefinitionResponse:
        pass

    def delete_subscription_definition(self, SubscriptionDefinitionId: str) -> DeleteSubscriptionDefinitionResponse:
        pass

    def disassociate_role_from_group(self, GroupId: str) -> DisassociateRoleFromGroupResponse:
        pass

    def disassociate_service_role_from_account(self) -> DisassociateServiceRoleFromAccountResponse:
        pass

    def get_associated_role(self, GroupId: str) -> GetAssociatedRoleResponse:
        pass

    def get_bulk_deployment_status(self, BulkDeploymentId: str) -> GetBulkDeploymentStatusResponse:
        pass

    def get_connectivity_info(self, ThingName: str) -> GetConnectivityInfoResponse:
        pass

    def get_connector_definition(self, ConnectorDefinitionId: str) -> GetConnectorDefinitionResponse:
        pass

    def get_connector_definition_version(self, ConnectorDefinitionVersionId: str, ConnectorDefinitionId: str, NextToken: str=None) -> GetConnectorDefinitionVersionResponse:
        pass

    def get_core_definition(self, CoreDefinitionId: str) -> GetCoreDefinitionResponse:
        pass

    def get_core_definition_version(self, CoreDefinitionVersionId: str, CoreDefinitionId: str) -> GetCoreDefinitionVersionResponse:
        pass

    def get_deployment_status(self, GroupId: str, DeploymentId: str) -> GetDeploymentStatusResponse:
        pass

    def get_device_definition(self, DeviceDefinitionId: str) -> GetDeviceDefinitionResponse:
        pass

    def get_device_definition_version(self, DeviceDefinitionVersionId: str, DeviceDefinitionId: str, NextToken: str=None) -> GetDeviceDefinitionVersionResponse:
        pass

    def get_function_definition(self, FunctionDefinitionId: str) -> GetFunctionDefinitionResponse:
        pass

    def get_function_definition_version(self, FunctionDefinitionVersionId: str, FunctionDefinitionId: str, NextToken: str=None) -> GetFunctionDefinitionVersionResponse:
        pass

    def get_group(self, GroupId: str) -> GetGroupResponse:
        pass

    def get_group_certificate_authority(self, GroupId: str, CertificateAuthorityId: str) -> GetGroupCertificateAuthorityResponse:
        pass

    def get_group_certificate_configuration(self, GroupId: str) -> GetGroupCertificateConfigurationResponse:
        pass

    def get_group_version(self, GroupVersionId: str, GroupId: str) -> GetGroupVersionResponse:
        pass

    def get_logger_definition(self, LoggerDefinitionId: str) -> GetLoggerDefinitionResponse:
        pass

    def get_logger_definition_version(self, LoggerDefinitionVersionId: str, LoggerDefinitionId: str, NextToken: str=None) -> GetLoggerDefinitionVersionResponse:
        pass

    def get_resource_definition(self, ResourceDefinitionId: str) -> GetResourceDefinitionResponse:
        pass

    def get_resource_definition_version(self, ResourceDefinitionVersionId: str, ResourceDefinitionId: str) -> GetResourceDefinitionVersionResponse:
        pass

    def get_service_role_for_account(self) -> GetServiceRoleForAccountResponse:
        pass

    def get_subscription_definition(self, SubscriptionDefinitionId: str) -> GetSubscriptionDefinitionResponse:
        pass

    def get_subscription_definition_version(self, SubscriptionDefinitionVersionId: str, SubscriptionDefinitionId: str, NextToken: str=None) -> GetSubscriptionDefinitionVersionResponse:
        pass

    def list_bulk_deployment_detailed_reports(self, BulkDeploymentId: str, MaxResults: str=None, NextToken: str=None) -> ListBulkDeploymentDetailedReportsResponse:
        pass

    def list_bulk_deployments(self, MaxResults: str=None, NextToken: str=None) -> ListBulkDeploymentsResponse:
        pass

    def list_connector_definition_versions(self, ConnectorDefinitionId: str, MaxResults: str=None, NextToken: str=None) -> ListConnectorDefinitionVersionsResponse:
        pass

    def list_connector_definitions(self, MaxResults: str=None, NextToken: str=None) -> ListConnectorDefinitionsResponse:
        pass

    def list_core_definition_versions(self, CoreDefinitionId: str, MaxResults: str=None, NextToken: str=None) -> ListCoreDefinitionVersionsResponse:
        pass

    def list_core_definitions(self, MaxResults: str=None, NextToken: str=None) -> ListCoreDefinitionsResponse:
        pass

    def list_deployments(self, GroupId: str, MaxResults: str=None, NextToken: str=None) -> ListDeploymentsResponse:
        pass

    def list_device_definition_versions(self, DeviceDefinitionId: str, MaxResults: str=None, NextToken: str=None) -> ListDeviceDefinitionVersionsResponse:
        pass

    def list_device_definitions(self, MaxResults: str=None, NextToken: str=None) -> ListDeviceDefinitionsResponse:
        pass

    def list_function_definition_versions(self, FunctionDefinitionId: str, MaxResults: str=None, NextToken: str=None) -> ListFunctionDefinitionVersionsResponse:
        pass

    def list_function_definitions(self, MaxResults: str=None, NextToken: str=None) -> ListFunctionDefinitionsResponse:
        pass

    def list_group_certificate_authorities(self, GroupId: str) -> ListGroupCertificateAuthoritiesResponse:
        pass

    def list_group_versions(self, GroupId: str, MaxResults: str=None, NextToken: str=None) -> ListGroupVersionsResponse:
        pass

    def list_groups(self, MaxResults: str=None, NextToken: str=None) -> ListGroupsResponse:
        pass

    def list_logger_definition_versions(self, LoggerDefinitionId: str, MaxResults: str=None, NextToken: str=None) -> ListLoggerDefinitionVersionsResponse:
        pass

    def list_logger_definitions(self, MaxResults: str=None, NextToken: str=None) -> ListLoggerDefinitionsResponse:
        pass

    def list_resource_definition_versions(self, ResourceDefinitionId: str, MaxResults: str=None, NextToken: str=None) -> ListResourceDefinitionVersionsResponse:
        pass

    def list_resource_definitions(self, MaxResults: str=None, NextToken: str=None) -> ListResourceDefinitionsResponse:
        pass

    def list_subscription_definition_versions(self, SubscriptionDefinitionId: str, MaxResults: str=None, NextToken: str=None) -> ListSubscriptionDefinitionVersionsResponse:
        pass

    def list_subscription_definitions(self, MaxResults: str=None, NextToken: str=None) -> ListSubscriptionDefinitionsResponse:
        pass

    def reset_deployments(self, GroupId: str, AmznClientToken: str=None, Force: __boolean=None) -> ResetDeploymentsResponse:
        pass

    def start_bulk_deployment(self, AmznClientToken: str=None, ExecutionRoleArn: str=None, InputFileUri: str=None) -> StartBulkDeploymentResponse:
        pass

    def stop_bulk_deployment(self, BulkDeploymentId: str) -> StopBulkDeploymentResponse:
        pass

    def update_connectivity_info(self, ThingName: str, ConnectivityInfo: List[ConnectivityInfo]=None) -> UpdateConnectivityInfoResponse:
        pass

    def update_connector_definition(self, ConnectorDefinitionId: str, Name: str=None) -> UpdateConnectorDefinitionResponse:
        pass

    def update_core_definition(self, CoreDefinitionId: str, Name: str=None) -> UpdateCoreDefinitionResponse:
        pass

    def update_device_definition(self, DeviceDefinitionId: str, Name: str=None) -> UpdateDeviceDefinitionResponse:
        pass

    def update_function_definition(self, FunctionDefinitionId: str, Name: str=None) -> UpdateFunctionDefinitionResponse:
        pass

    def update_group(self, GroupId: str, Name: str=None) -> UpdateGroupResponse:
        pass

    def update_group_certificate_configuration(self, GroupId: str, CertificateExpiryInMilliseconds: str=None) -> UpdateGroupCertificateConfigurationResponse:
        pass

    def update_logger_definition(self, LoggerDefinitionId: str, Name: str=None) -> UpdateLoggerDefinitionResponse:
        pass

    def update_resource_definition(self, ResourceDefinitionId: str, Name: str=None) -> UpdateResourceDefinitionResponse:
        pass

    def update_subscription_definition(self, SubscriptionDefinitionId: str, Name: str=None) -> UpdateSubscriptionDefinitionResponse:
        pass


class GuardDuty(BaseClient):
    class AcceptInvitationRequest(Mapping):
        pass

    class AcceptInvitationResponse(Mapping):
        pass

    class ArchiveFindingsRequest(Mapping):
        pass

    class ArchiveFindingsResponse(Mapping):
        pass

    class FindingId(object):
        pass

    class CreateDetectorRequest(Mapping):
        pass

    class CreateDetectorResponse(Mapping):
        pass

    class Enable(object):
        pass

    class CreateFilterRequest(Mapping):
        pass

    class CreateFilterResponse(Mapping):
        pass

    class FindingCriteria(Mapping):
        pass

    class CreateIPSetRequest(Mapping):
        pass

    class CreateIPSetResponse(Mapping):
        pass

    class Activate(object):
        pass

    class CreateMembersRequest(Mapping):
        pass

    class CreateMembersResponse(Mapping):
        pass

    class AccountDetail(Mapping):
        pass

    class CreateSampleFindingsRequest(Mapping):
        pass

    class CreateSampleFindingsResponse(Mapping):
        pass

    class FindingType(object):
        pass

    class CreateThreatIntelSetRequest(Mapping):
        pass

    class CreateThreatIntelSetResponse(Mapping):
        pass

    class DeclineInvitationsRequest(Mapping):
        pass

    class DeclineInvitationsResponse(Mapping):
        pass

    class __string(object):
        pass

    class DeleteDetectorRequest(Mapping):
        pass

    class DeleteDetectorResponse(Mapping):
        pass

    class DeleteFilterRequest(Mapping):
        pass

    class DeleteFilterResponse(Mapping):
        pass

    class DeleteIPSetRequest(Mapping):
        pass

    class DeleteIPSetResponse(Mapping):
        pass

    class DeleteInvitationsRequest(Mapping):
        pass

    class DeleteInvitationsResponse(Mapping):
        pass

    class DeleteMembersRequest(Mapping):
        pass

    class DeleteMembersResponse(Mapping):
        pass

    class DeleteThreatIntelSetRequest(Mapping):
        pass

    class DeleteThreatIntelSetResponse(Mapping):
        pass

    class DisassociateFromMasterAccountRequest(Mapping):
        pass

    class DisassociateFromMasterAccountResponse(Mapping):
        pass

    class DisassociateMembersRequest(Mapping):
        pass

    class DisassociateMembersResponse(Mapping):
        pass

    class GetDetectorRequest(Mapping):
        pass

    class GetDetectorResponse(Mapping):
        pass

    class GetFilterRequest(Mapping):
        pass

    class GetFilterResponse(Mapping):
        pass

    class GetFindingsRequest(Mapping):
        pass

    class GetFindingsResponse(Mapping):
        pass

    class SortCriteria(Mapping):
        pass

    class GetFindingsStatisticsRequest(Mapping):
        pass

    class GetFindingsStatisticsResponse(Mapping):
        pass

    class FindingStatisticType(object):
        pass

    class GetIPSetRequest(Mapping):
        pass

    class GetIPSetResponse(Mapping):
        pass

    class GetInvitationsCountRequest(Mapping):
        pass

    class GetInvitationsCountResponse(Mapping):
        pass

    class GetMasterAccountRequest(Mapping):
        pass

    class GetMasterAccountResponse(Mapping):
        pass

    class GetMembersRequest(Mapping):
        pass

    class GetMembersResponse(Mapping):
        pass

    class GetThreatIntelSetRequest(Mapping):
        pass

    class GetThreatIntelSetResponse(Mapping):
        pass

    class InviteMembersRequest(Mapping):
        pass

    class InviteMembersResponse(Mapping):
        pass

    class __boolean(object):
        pass

    class ListDetectorsRequest(Mapping):
        pass

    class ListDetectorsResponse(Mapping):
        pass

    class ListFiltersRequest(Mapping):
        pass

    class ListFiltersResponse(Mapping):
        pass

    class ListFindingsRequest(Mapping):
        pass

    class ListFindingsResponse(Mapping):
        pass

    class ListIPSetsRequest(Mapping):
        pass

    class ListIPSetsResponse(Mapping):
        pass

    class ListInvitationsRequest(Mapping):
        pass

    class ListInvitationsResponse(Mapping):
        pass

    class ListMembersRequest(Mapping):
        pass

    class ListMembersResponse(Mapping):
        pass

    class ListThreatIntelSetsRequest(Mapping):
        pass

    class ListThreatIntelSetsResponse(Mapping):
        pass

    class StartMonitoringMembersRequest(Mapping):
        pass

    class StartMonitoringMembersResponse(Mapping):
        pass

    class StopMonitoringMembersRequest(Mapping):
        pass

    class StopMonitoringMembersResponse(Mapping):
        pass

    class UnarchiveFindingsRequest(Mapping):
        pass

    class UnarchiveFindingsResponse(Mapping):
        pass

    class UpdateDetectorRequest(Mapping):
        pass

    class UpdateDetectorResponse(Mapping):
        pass

    class UpdateFilterRequest(Mapping):
        pass

    class UpdateFilterResponse(Mapping):
        pass

    class UpdateFindingsFeedbackRequest(Mapping):
        pass

    class UpdateFindingsFeedbackResponse(Mapping):
        pass

    class UpdateIPSetRequest(Mapping):
        pass

    class UpdateIPSetResponse(Mapping):
        pass

    class UpdateThreatIntelSetRequest(Mapping):
        pass

    class UpdateThreatIntelSetResponse(Mapping):
        pass

    def accept_invitation(self, MasterId: str, InvitationId: str, DetectorId: str) -> AcceptInvitationResponse:
        pass

    def archive_findings(self, FindingIds: List[FindingId], DetectorId: str) -> ArchiveFindingsResponse:
        pass

    def create_detector(self, Enable: Enable, ClientToken: str=None, FindingPublishingFrequency: str=None) -> CreateDetectorResponse:
        pass

    def create_filter(self, Name: str, FindingCriteria: FindingCriteria, DetectorId: str, Action: str=None, ClientToken: str=None, Description: str=None, Rank: int=None) -> CreateFilterResponse:
        pass

    def create_ip_set(self, Name: str, Location: str, Format: str, DetectorId: str, Activate: Activate, ClientToken: str=None) -> CreateIPSetResponse:
        pass

    def create_members(self, DetectorId: str, AccountDetails: List[AccountDetail]) -> CreateMembersResponse:
        pass

    def create_sample_findings(self, DetectorId: str, FindingTypes: List[FindingType]=None) -> CreateSampleFindingsResponse:
        pass

    def create_threat_intel_set(self, Name: str, Location: str, Format: str, DetectorId: str, Activate: Activate, ClientToken: str=None) -> CreateThreatIntelSetResponse:
        pass

    def decline_invitations(self, AccountIds: List[__string]) -> DeclineInvitationsResponse:
        pass

    def delete_detector(self, DetectorId: str) -> DeleteDetectorResponse:
        pass

    def delete_filter(self, FilterName: str, DetectorId: str) -> DeleteFilterResponse:
        pass

    def delete_ip_set(self, IpSetId: str, DetectorId: str) -> DeleteIPSetResponse:
        pass

    def delete_invitations(self, AccountIds: List[__string]) -> DeleteInvitationsResponse:
        pass

    def delete_members(self, DetectorId: str, AccountIds: List[__string]) -> DeleteMembersResponse:
        pass

    def delete_threat_intel_set(self, ThreatIntelSetId: str, DetectorId: str) -> DeleteThreatIntelSetResponse:
        pass

    def disassociate_from_master_account(self, DetectorId: str) -> DisassociateFromMasterAccountResponse:
        pass

    def disassociate_members(self, DetectorId: str, AccountIds: List[__string]) -> DisassociateMembersResponse:
        pass

    def get_detector(self, DetectorId: str) -> GetDetectorResponse:
        pass

    def get_filter(self, FilterName: str, DetectorId: str) -> GetFilterResponse:
        pass

    def get_findings(self, FindingIds: List[FindingId], DetectorId: str, SortCriteria: SortCriteria=None) -> GetFindingsResponse:
        pass

    def get_findings_statistics(self, FindingStatisticTypes: List[FindingStatisticType], DetectorId: str, FindingCriteria: FindingCriteria=None) -> GetFindingsStatisticsResponse:
        pass

    def get_ip_set(self, IpSetId: str, DetectorId: str) -> GetIPSetResponse:
        pass

    def get_invitations_count(self) -> GetInvitationsCountResponse:
        pass

    def get_master_account(self, DetectorId: str) -> GetMasterAccountResponse:
        pass

    def get_members(self, DetectorId: str, AccountIds: List[__string]) -> GetMembersResponse:
        pass

    def get_threat_intel_set(self, ThreatIntelSetId: str, DetectorId: str) -> GetThreatIntelSetResponse:
        pass

    def invite_members(self, DetectorId: str, AccountIds: List[__string], DisableEmailNotification: __boolean=None, Message: str=None) -> InviteMembersResponse:
        pass

    def list_detectors(self, MaxResults: int=None, NextToken: str=None) -> ListDetectorsResponse:
        pass

    def list_filters(self, DetectorId: str, MaxResults: int=None, NextToken: str=None) -> ListFiltersResponse:
        pass

    def list_findings(self, DetectorId: str, FindingCriteria: FindingCriteria=None, MaxResults: int=None, NextToken: str=None, SortCriteria: SortCriteria=None) -> ListFindingsResponse:
        pass

    def list_ip_sets(self, DetectorId: str, MaxResults: int=None, NextToken: str=None) -> ListIPSetsResponse:
        pass

    def list_invitations(self, MaxResults: int=None, NextToken: str=None) -> ListInvitationsResponse:
        pass

    def list_members(self, DetectorId: str, MaxResults: int=None, NextToken: str=None, OnlyAssociated: str=None) -> ListMembersResponse:
        pass

    def list_threat_intel_sets(self, DetectorId: str, MaxResults: int=None, NextToken: str=None) -> ListThreatIntelSetsResponse:
        pass

    def start_monitoring_members(self, DetectorId: str, AccountIds: List[__string]) -> StartMonitoringMembersResponse:
        pass

    def stop_monitoring_members(self, DetectorId: str, AccountIds: List[__string]) -> StopMonitoringMembersResponse:
        pass

    def unarchive_findings(self, FindingIds: List[FindingId], DetectorId: str) -> UnarchiveFindingsResponse:
        pass

    def update_detector(self, DetectorId: str, Enable: Enable=None, FindingPublishingFrequency: str=None) -> UpdateDetectorResponse:
        pass

    def update_filter(self, FilterName: str, DetectorId: str, Action: str=None, Description: str=None, FindingCriteria: FindingCriteria=None, Rank: int=None) -> UpdateFilterResponse:
        pass

    def update_findings_feedback(self, FindingIds: List[FindingId], Feedback: str, DetectorId: str, Comments: str=None) -> UpdateFindingsFeedbackResponse:
        pass

    def update_ip_set(self, IpSetId: str, DetectorId: str, Activate: Activate=None, Location: str=None, Name: str=None) -> UpdateIPSetResponse:
        pass

    def update_threat_intel_set(self, ThreatIntelSetId: str, DetectorId: str, Activate: Activate=None, Location: str=None, Name: str=None) -> UpdateThreatIntelSetResponse:
        pass


class Health(BaseClient):
    class DescribeAffectedEntitiesRequest(Mapping):
        pass

    class DescribeAffectedEntitiesResponse(Mapping):
        pass

    class EntityFilter(Mapping):
        pass

    class DescribeEntityAggregatesRequest(Mapping):
        pass

    class DescribeEntityAggregatesResponse(Mapping):
        pass

    class eventArn(object):
        pass

    class DescribeEventAggregatesRequest(Mapping):
        pass

    class DescribeEventAggregatesResponse(Mapping):
        pass

    class EventFilter(Mapping):
        pass

    class DescribeEventDetailsRequest(Mapping):
        pass

    class DescribeEventDetailsResponse(Mapping):
        pass

    class DescribeEventTypesRequest(Mapping):
        pass

    class DescribeEventTypesResponse(Mapping):
        pass

    class EventTypeFilter(Mapping):
        pass

    class DescribeEventsRequest(Mapping):
        pass

    class DescribeEventsResponse(Mapping):
        pass

    def describe_affected_entities(self, filter: EntityFilter, locale: str=None, nextToken: str=None, maxResults: int=None) -> DescribeAffectedEntitiesResponse:
        pass

    def describe_entity_aggregates(self, eventArns: List[eventArn]=None) -> DescribeEntityAggregatesResponse:
        pass

    def describe_event_aggregates(self, aggregateField: str, filter: EventFilter=None, maxResults: int=None, nextToken: str=None) -> DescribeEventAggregatesResponse:
        pass

    def describe_event_details(self, eventArns: List[eventArn], locale: str=None) -> DescribeEventDetailsResponse:
        pass

    def describe_event_types(self, filter: EventTypeFilter=None, locale: str=None, nextToken: str=None, maxResults: int=None) -> DescribeEventTypesResponse:
        pass

    def describe_events(self, filter: EventFilter=None, nextToken: str=None, maxResults: int=None, locale: str=None) -> DescribeEventsResponse:
        pass


class IAM(BaseClient):
    class AddClientIDToOpenIDConnectProviderRequest(Mapping):
        pass

    class AddRoleToInstanceProfileRequest(Mapping):
        pass

    class AddUserToGroupRequest(Mapping):
        pass

    class AttachGroupPolicyRequest(Mapping):
        pass

    class AttachRolePolicyRequest(Mapping):
        pass

    class AttachUserPolicyRequest(Mapping):
        pass

    class ChangePasswordRequest(Mapping):
        pass

    class CreateAccessKeyRequest(Mapping):
        pass

    class CreateAccessKeyResponse(Mapping):
        pass

    class CreateAccountAliasRequest(Mapping):
        pass

    class CreateGroupRequest(Mapping):
        pass

    class CreateGroupResponse(Mapping):
        pass

    class CreateInstanceProfileRequest(Mapping):
        pass

    class CreateInstanceProfileResponse(Mapping):
        pass

    class CreateLoginProfileRequest(Mapping):
        pass

    class CreateLoginProfileResponse(Mapping):
        pass

    class booleanType(object):
        pass

    class CreateOpenIDConnectProviderRequest(Mapping):
        pass

    class CreateOpenIDConnectProviderResponse(Mapping):
        pass

    class clientIDType(object):
        pass

    class thumbprintType(object):
        pass

    class CreatePolicyRequest(Mapping):
        pass

    class CreatePolicyResponse(Mapping):
        pass

    class CreatePolicyVersionRequest(Mapping):
        pass

    class CreatePolicyVersionResponse(Mapping):
        pass

    class CreateRoleRequest(Mapping):
        pass

    class CreateRoleResponse(Mapping):
        pass

    class Tag(Mapping):
        pass

    class CreateSAMLProviderRequest(Mapping):
        pass

    class CreateSAMLProviderResponse(Mapping):
        pass

    class CreateServiceLinkedRoleRequest(Mapping):
        pass

    class CreateServiceLinkedRoleResponse(Mapping):
        pass

    class CreateServiceSpecificCredentialRequest(Mapping):
        pass

    class CreateServiceSpecificCredentialResponse(Mapping):
        pass

    class CreateUserRequest(Mapping):
        pass

    class CreateUserResponse(Mapping):
        pass

    class CreateVirtualMFADeviceRequest(Mapping):
        pass

    class CreateVirtualMFADeviceResponse(Mapping):
        pass

    class DeactivateMFADeviceRequest(Mapping):
        pass

    class DeleteAccessKeyRequest(Mapping):
        pass

    class DeleteAccountAliasRequest(Mapping):
        pass

    class DeleteGroupRequest(Mapping):
        pass

    class DeleteGroupPolicyRequest(Mapping):
        pass

    class DeleteInstanceProfileRequest(Mapping):
        pass

    class DeleteLoginProfileRequest(Mapping):
        pass

    class DeleteOpenIDConnectProviderRequest(Mapping):
        pass

    class DeletePolicyRequest(Mapping):
        pass

    class DeletePolicyVersionRequest(Mapping):
        pass

    class DeleteRoleRequest(Mapping):
        pass

    class DeleteRolePermissionsBoundaryRequest(Mapping):
        pass

    class DeleteRolePolicyRequest(Mapping):
        pass

    class DeleteSAMLProviderRequest(Mapping):
        pass

    class DeleteSSHPublicKeyRequest(Mapping):
        pass

    class DeleteServerCertificateRequest(Mapping):
        pass

    class DeleteServiceLinkedRoleRequest(Mapping):
        pass

    class DeleteServiceLinkedRoleResponse(Mapping):
        pass

    class DeleteServiceSpecificCredentialRequest(Mapping):
        pass

    class DeleteSigningCertificateRequest(Mapping):
        pass

    class DeleteUserRequest(Mapping):
        pass

    class DeleteUserPermissionsBoundaryRequest(Mapping):
        pass

    class DeleteUserPolicyRequest(Mapping):
        pass

    class DeleteVirtualMFADeviceRequest(Mapping):
        pass

    class DetachGroupPolicyRequest(Mapping):
        pass

    class DetachRolePolicyRequest(Mapping):
        pass

    class DetachUserPolicyRequest(Mapping):
        pass

    class EnableMFADeviceRequest(Mapping):
        pass

    class GenerateCredentialReportResponse(Mapping):
        pass

    class GenerateServiceLastAccessedDetailsRequest(Mapping):
        pass

    class GenerateServiceLastAccessedDetailsResponse(Mapping):
        pass

    class GetAccessKeyLastUsedRequest(Mapping):
        pass

    class GetAccessKeyLastUsedResponse(Mapping):
        pass

    class GetAccountAuthorizationDetailsRequest(Mapping):
        pass

    class GetAccountAuthorizationDetailsResponse(Mapping):
        pass

    class EntityType(object):
        pass

    class GetAccountPasswordPolicyResponse(Mapping):
        pass

    class GetAccountSummaryResponse(Mapping):
        pass

    class GetContextKeysForCustomPolicyRequest(Mapping):
        pass

    class GetContextKeysForPolicyResponse(Mapping):
        pass

    class policyDocumentType(object):
        pass

    class GetContextKeysForPrincipalPolicyRequest(Mapping):
        pass

    class GetCredentialReportResponse(Mapping):
        pass

    class GetGroupRequest(Mapping):
        pass

    class GetGroupResponse(Mapping):
        pass

    class GetGroupPolicyRequest(Mapping):
        pass

    class GetGroupPolicyResponse(Mapping):
        pass

    class GetInstanceProfileRequest(Mapping):
        pass

    class GetInstanceProfileResponse(Mapping):
        pass

    class GetLoginProfileRequest(Mapping):
        pass

    class GetLoginProfileResponse(Mapping):
        pass

    class GetOpenIDConnectProviderRequest(Mapping):
        pass

    class GetOpenIDConnectProviderResponse(Mapping):
        pass

    class GetPolicyRequest(Mapping):
        pass

    class GetPolicyResponse(Mapping):
        pass

    class GetPolicyVersionRequest(Mapping):
        pass

    class GetPolicyVersionResponse(Mapping):
        pass

    class GetRoleRequest(Mapping):
        pass

    class GetRoleResponse(Mapping):
        pass

    class GetRolePolicyRequest(Mapping):
        pass

    class GetRolePolicyResponse(Mapping):
        pass

    class GetSAMLProviderRequest(Mapping):
        pass

    class GetSAMLProviderResponse(Mapping):
        pass

    class GetSSHPublicKeyRequest(Mapping):
        pass

    class GetSSHPublicKeyResponse(Mapping):
        pass

    class GetServerCertificateRequest(Mapping):
        pass

    class GetServerCertificateResponse(Mapping):
        pass

    class GetServiceLastAccessedDetailsRequest(Mapping):
        pass

    class GetServiceLastAccessedDetailsResponse(Mapping):
        pass

    class GetServiceLastAccessedDetailsWithEntitiesRequest(Mapping):
        pass

    class GetServiceLastAccessedDetailsWithEntitiesResponse(Mapping):
        pass

    class GetServiceLinkedRoleDeletionStatusRequest(Mapping):
        pass

    class GetServiceLinkedRoleDeletionStatusResponse(Mapping):
        pass

    class GetUserRequest(Mapping):
        pass

    class GetUserResponse(Mapping):
        pass

    class GetUserPolicyRequest(Mapping):
        pass

    class GetUserPolicyResponse(Mapping):
        pass

    class ListAccessKeysRequest(Mapping):
        pass

    class ListAccessKeysResponse(Mapping):
        pass

    class ListAccountAliasesRequest(Mapping):
        pass

    class ListAccountAliasesResponse(Mapping):
        pass

    class ListAttachedGroupPoliciesRequest(Mapping):
        pass

    class ListAttachedGroupPoliciesResponse(Mapping):
        pass

    class ListAttachedRolePoliciesRequest(Mapping):
        pass

    class ListAttachedRolePoliciesResponse(Mapping):
        pass

    class ListAttachedUserPoliciesRequest(Mapping):
        pass

    class ListAttachedUserPoliciesResponse(Mapping):
        pass

    class ListEntitiesForPolicyRequest(Mapping):
        pass

    class ListEntitiesForPolicyResponse(Mapping):
        pass

    class ListGroupPoliciesRequest(Mapping):
        pass

    class ListGroupPoliciesResponse(Mapping):
        pass

    class ListGroupsRequest(Mapping):
        pass

    class ListGroupsResponse(Mapping):
        pass

    class ListGroupsForUserRequest(Mapping):
        pass

    class ListGroupsForUserResponse(Mapping):
        pass

    class ListInstanceProfilesRequest(Mapping):
        pass

    class ListInstanceProfilesResponse(Mapping):
        pass

    class ListInstanceProfilesForRoleRequest(Mapping):
        pass

    class ListInstanceProfilesForRoleResponse(Mapping):
        pass

    class ListMFADevicesRequest(Mapping):
        pass

    class ListMFADevicesResponse(Mapping):
        pass

    class ListOpenIDConnectProvidersRequest(Mapping):
        pass

    class ListOpenIDConnectProvidersResponse(Mapping):
        pass

    class ListPoliciesRequest(Mapping):
        pass

    class ListPoliciesResponse(Mapping):
        pass

    class ListPoliciesGrantingServiceAccessRequest(Mapping):
        pass

    class ListPoliciesGrantingServiceAccessResponse(Mapping):
        pass

    class serviceNamespaceType(object):
        pass

    class ListPolicyVersionsRequest(Mapping):
        pass

    class ListPolicyVersionsResponse(Mapping):
        pass

    class ListRolePoliciesRequest(Mapping):
        pass

    class ListRolePoliciesResponse(Mapping):
        pass

    class ListRoleTagsRequest(Mapping):
        pass

    class ListRoleTagsResponse(Mapping):
        pass

    class ListRolesRequest(Mapping):
        pass

    class ListRolesResponse(Mapping):
        pass

    class ListSAMLProvidersRequest(Mapping):
        pass

    class ListSAMLProvidersResponse(Mapping):
        pass

    class ListSSHPublicKeysRequest(Mapping):
        pass

    class ListSSHPublicKeysResponse(Mapping):
        pass

    class ListServerCertificatesRequest(Mapping):
        pass

    class ListServerCertificatesResponse(Mapping):
        pass

    class ListServiceSpecificCredentialsRequest(Mapping):
        pass

    class ListServiceSpecificCredentialsResponse(Mapping):
        pass

    class ListSigningCertificatesRequest(Mapping):
        pass

    class ListSigningCertificatesResponse(Mapping):
        pass

    class ListUserPoliciesRequest(Mapping):
        pass

    class ListUserPoliciesResponse(Mapping):
        pass

    class ListUserTagsRequest(Mapping):
        pass

    class ListUserTagsResponse(Mapping):
        pass

    class ListUsersRequest(Mapping):
        pass

    class ListUsersResponse(Mapping):
        pass

    class ListVirtualMFADevicesRequest(Mapping):
        pass

    class ListVirtualMFADevicesResponse(Mapping):
        pass

    class PutGroupPolicyRequest(Mapping):
        pass

    class PutRolePermissionsBoundaryRequest(Mapping):
        pass

    class PutRolePolicyRequest(Mapping):
        pass

    class PutUserPermissionsBoundaryRequest(Mapping):
        pass

    class PutUserPolicyRequest(Mapping):
        pass

    class RemoveClientIDFromOpenIDConnectProviderRequest(Mapping):
        pass

    class RemoveRoleFromInstanceProfileRequest(Mapping):
        pass

    class RemoveUserFromGroupRequest(Mapping):
        pass

    class ResetServiceSpecificCredentialRequest(Mapping):
        pass

    class ResetServiceSpecificCredentialResponse(Mapping):
        pass

    class ResyncMFADeviceRequest(Mapping):
        pass

    class SetDefaultPolicyVersionRequest(Mapping):
        pass

    class SimulateCustomPolicyRequest(Mapping):
        pass

    class SimulatePolicyResponse(Mapping):
        pass

    class ActionNameType(object):
        pass

    class ResourceNameType(object):
        pass

    class ContextEntry(Mapping):
        pass

    class SimulatePrincipalPolicyRequest(Mapping):
        pass

    class TagRoleRequest(Mapping):
        pass

    class TagUserRequest(Mapping):
        pass

    class UntagRoleRequest(Mapping):
        pass

    class tagKeyType(object):
        pass

    class UntagUserRequest(Mapping):
        pass

    class UpdateAccessKeyRequest(Mapping):
        pass

    class UpdateAccountPasswordPolicyRequest(Mapping):
        pass

    class booleanObjectType(object):
        pass

    class UpdateAssumeRolePolicyRequest(Mapping):
        pass

    class UpdateGroupRequest(Mapping):
        pass

    class UpdateLoginProfileRequest(Mapping):
        pass

    class UpdateOpenIDConnectProviderThumbprintRequest(Mapping):
        pass

    class UpdateRoleRequest(Mapping):
        pass

    class UpdateRoleResponse(Mapping):
        pass

    class UpdateRoleDescriptionRequest(Mapping):
        pass

    class UpdateRoleDescriptionResponse(Mapping):
        pass

    class UpdateSAMLProviderRequest(Mapping):
        pass

    class UpdateSAMLProviderResponse(Mapping):
        pass

    class UpdateSSHPublicKeyRequest(Mapping):
        pass

    class UpdateServerCertificateRequest(Mapping):
        pass

    class UpdateServiceSpecificCredentialRequest(Mapping):
        pass

    class UpdateSigningCertificateRequest(Mapping):
        pass

    class UpdateUserRequest(Mapping):
        pass

    class UploadSSHPublicKeyRequest(Mapping):
        pass

    class UploadSSHPublicKeyResponse(Mapping):
        pass

    class UploadServerCertificateRequest(Mapping):
        pass

    class UploadServerCertificateResponse(Mapping):
        pass

    class UploadSigningCertificateRequest(Mapping):
        pass

    class UploadSigningCertificateResponse(Mapping):
        pass

    def add_client_id_to_open_id_connect_provider(self, ClientID: str, OpenIDConnectProviderArn: str):
        pass

    def add_role_to_instance_profile(self, RoleName: str, InstanceProfileName: str):
        pass

    def add_user_to_group(self, UserName: str, GroupName: str):
        pass

    def attach_group_policy(self, PolicyArn: str, GroupName: str):
        pass

    def attach_role_policy(self, PolicyArn: str, RoleName: str):
        pass

    def attach_user_policy(self, PolicyArn: str, UserName: str):
        pass

    def change_password(self, NewPassword: str, OldPassword: str):
        pass

    def create_access_key(self, UserName: str=None) -> CreateAccessKeyResponse:
        pass

    def create_account_alias(self, AccountAlias: str):
        pass

    def create_group(self, GroupName: str, Path: str=None) -> CreateGroupResponse:
        pass

    def create_instance_profile(self, InstanceProfileName: str, Path: str=None) -> CreateInstanceProfileResponse:
        pass

    def create_login_profile(self, Password: str, UserName: str, PasswordResetRequired: booleanType=None) -> CreateLoginProfileResponse:
        pass

    def create_open_id_connect_provider(self, ThumbprintList: List[thumbprintType], Url: str, ClientIDList: List[clientIDType]=None) -> CreateOpenIDConnectProviderResponse:
        pass

    def create_policy(self, PolicyDocument: str, PolicyName: str, Path: str=None, Description: str=None) -> CreatePolicyResponse:
        pass

    def create_policy_version(self, PolicyDocument: str, PolicyArn: str, SetAsDefault: booleanType=None) -> CreatePolicyVersionResponse:
        pass

    def create_role(self, AssumeRolePolicyDocument: str, RoleName: str, Path: str=None, Description: str=None, MaxSessionDuration: int=None, PermissionsBoundary: str=None, Tags: List[Tag]=None) -> CreateRoleResponse:
        pass

    def create_saml_provider(self, Name: str, SAMLMetadataDocument: str) -> CreateSAMLProviderResponse:
        pass

    def create_service_linked_role(self, AWSServiceName: str, Description: str=None, CustomSuffix: str=None) -> CreateServiceLinkedRoleResponse:
        pass

    def create_service_specific_credential(self, ServiceName: str, UserName: str) -> CreateServiceSpecificCredentialResponse:
        pass

    def create_user(self, UserName: str, Path: str=None, PermissionsBoundary: str=None, Tags: List[Tag]=None) -> CreateUserResponse:
        pass

    def create_virtual_mfa_device(self, VirtualMFADeviceName: str, Path: str=None) -> CreateVirtualMFADeviceResponse:
        pass

    def deactivate_mfa_device(self, SerialNumber: str, UserName: str):
        pass

    def delete_access_key(self, AccessKeyId: str, UserName: str=None):
        pass

    def delete_account_alias(self, AccountAlias: str):
        pass

    def delete_account_password_policy(self):
        pass

    def delete_group(self, GroupName: str):
        pass

    def delete_group_policy(self, PolicyName: str, GroupName: str):
        pass

    def delete_instance_profile(self, InstanceProfileName: str):
        pass

    def delete_login_profile(self, UserName: str):
        pass

    def delete_open_id_connect_provider(self, OpenIDConnectProviderArn: str):
        pass

    def delete_policy(self, PolicyArn: str):
        pass

    def delete_policy_version(self, VersionId: str, PolicyArn: str):
        pass

    def delete_role(self, RoleName: str):
        pass

    def delete_role_permissions_boundary(self, RoleName: str):
        pass

    def delete_role_policy(self, PolicyName: str, RoleName: str):
        pass

    def delete_saml_provider(self, SAMLProviderArn: str):
        pass

    def delete_ssh_public_key(self, SSHPublicKeyId: str, UserName: str):
        pass

    def delete_server_certificate(self, ServerCertificateName: str):
        pass

    def delete_service_linked_role(self, RoleName: str) -> DeleteServiceLinkedRoleResponse:
        pass

    def delete_service_specific_credential(self, ServiceSpecificCredentialId: str, UserName: str=None):
        pass

    def delete_signing_certificate(self, CertificateId: str, UserName: str=None):
        pass

    def delete_user(self, UserName: str):
        pass

    def delete_user_permissions_boundary(self, UserName: str):
        pass

    def delete_user_policy(self, PolicyName: str, UserName: str):
        pass

    def delete_virtual_mfa_device(self, SerialNumber: str):
        pass

    def detach_group_policy(self, PolicyArn: str, GroupName: str):
        pass

    def detach_role_policy(self, PolicyArn: str, RoleName: str):
        pass

    def detach_user_policy(self, PolicyArn: str, UserName: str):
        pass

    def enable_mfa_device(self, AuthenticationCode2: str, AuthenticationCode1: str, SerialNumber: str, UserName: str):
        pass

    def generate_credential_report(self) -> GenerateCredentialReportResponse:
        pass

    def generate_service_last_accessed_details(self, Arn: str) -> GenerateServiceLastAccessedDetailsResponse:
        pass

    def get_access_key_last_used(self, AccessKeyId: str) -> GetAccessKeyLastUsedResponse:
        pass

    def get_account_authorization_details(self, Filter: List[EntityType]=None, MaxItems: int=None, Marker: str=None) -> GetAccountAuthorizationDetailsResponse:
        pass

    def get_account_password_policy(self) -> GetAccountPasswordPolicyResponse:
        pass

    def get_account_summary(self) -> GetAccountSummaryResponse:
        pass

    def get_context_keys_for_custom_policy(self, PolicyInputList: List[policyDocumentType]) -> GetContextKeysForPolicyResponse:
        pass

    def get_context_keys_for_principal_policy(self, PolicySourceArn: str, PolicyInputList: List[policyDocumentType]=None) -> GetContextKeysForPolicyResponse:
        pass

    def get_credential_report(self) -> GetCredentialReportResponse:
        pass

    def get_group(self, GroupName: str, Marker: str=None, MaxItems: int=None) -> GetGroupResponse:
        pass

    def get_group_policy(self, PolicyName: str, GroupName: str) -> GetGroupPolicyResponse:
        pass

    def get_instance_profile(self, InstanceProfileName: str) -> GetInstanceProfileResponse:
        pass

    def get_login_profile(self, UserName: str) -> GetLoginProfileResponse:
        pass

    def get_open_id_connect_provider(self, OpenIDConnectProviderArn: str) -> GetOpenIDConnectProviderResponse:
        pass

    def get_policy(self, PolicyArn: str) -> GetPolicyResponse:
        pass

    def get_policy_version(self, VersionId: str, PolicyArn: str) -> GetPolicyVersionResponse:
        pass

    def get_role(self, RoleName: str) -> GetRoleResponse:
        pass

    def get_role_policy(self, PolicyName: str, RoleName: str) -> GetRolePolicyResponse:
        pass

    def get_saml_provider(self, SAMLProviderArn: str) -> GetSAMLProviderResponse:
        pass

    def get_ssh_public_key(self, Encoding: str, SSHPublicKeyId: str, UserName: str) -> GetSSHPublicKeyResponse:
        pass

    def get_server_certificate(self, ServerCertificateName: str) -> GetServerCertificateResponse:
        pass

    def get_service_last_accessed_details(self, JobId: str, MaxItems: int=None, Marker: str=None) -> GetServiceLastAccessedDetailsResponse:
        pass

    def get_service_last_accessed_details_with_entities(self, ServiceNamespace: str, JobId: str, MaxItems: int=None, Marker: str=None) -> GetServiceLastAccessedDetailsWithEntitiesResponse:
        pass

    def get_service_linked_role_deletion_status(self, DeletionTaskId: str) -> GetServiceLinkedRoleDeletionStatusResponse:
        pass

    def get_user(self, UserName: str=None) -> GetUserResponse:
        pass

    def get_user_policy(self, PolicyName: str, UserName: str) -> GetUserPolicyResponse:
        pass

    def list_access_keys(self, UserName: str=None, Marker: str=None, MaxItems: int=None) -> ListAccessKeysResponse:
        pass

    def list_account_aliases(self, Marker: str=None, MaxItems: int=None) -> ListAccountAliasesResponse:
        pass

    def list_attached_group_policies(self, GroupName: str, PathPrefix: str=None, Marker: str=None, MaxItems: int=None) -> ListAttachedGroupPoliciesResponse:
        pass

    def list_attached_role_policies(self, RoleName: str, PathPrefix: str=None, Marker: str=None, MaxItems: int=None) -> ListAttachedRolePoliciesResponse:
        pass

    def list_attached_user_policies(self, UserName: str, PathPrefix: str=None, Marker: str=None, MaxItems: int=None) -> ListAttachedUserPoliciesResponse:
        pass

    def list_entities_for_policy(self, PolicyArn: str, EntityFilter: str=None, PathPrefix: str=None, PolicyUsageFilter: str=None, Marker: str=None, MaxItems: int=None) -> ListEntitiesForPolicyResponse:
        pass

    def list_group_policies(self, GroupName: str, Marker: str=None, MaxItems: int=None) -> ListGroupPoliciesResponse:
        pass

    def list_groups(self, PathPrefix: str=None, Marker: str=None, MaxItems: int=None) -> ListGroupsResponse:
        pass

    def list_groups_for_user(self, UserName: str, Marker: str=None, MaxItems: int=None) -> ListGroupsForUserResponse:
        pass

    def list_instance_profiles(self, PathPrefix: str=None, Marker: str=None, MaxItems: int=None) -> ListInstanceProfilesResponse:
        pass

    def list_instance_profiles_for_role(self, RoleName: str, Marker: str=None, MaxItems: int=None) -> ListInstanceProfilesForRoleResponse:
        pass

    def list_mfa_devices(self, UserName: str=None, Marker: str=None, MaxItems: int=None) -> ListMFADevicesResponse:
        pass

    def list_open_id_connect_providers(self) -> ListOpenIDConnectProvidersResponse:
        pass

    def list_policies(self, Scope: str=None, OnlyAttached: booleanType=None, PathPrefix: str=None, PolicyUsageFilter: str=None, Marker: str=None, MaxItems: int=None) -> ListPoliciesResponse:
        pass

    def list_policies_granting_service_access(self, ServiceNamespaces: List[serviceNamespaceType], Arn: str, Marker: str=None) -> ListPoliciesGrantingServiceAccessResponse:
        pass

    def list_policy_versions(self, PolicyArn: str, Marker: str=None, MaxItems: int=None) -> ListPolicyVersionsResponse:
        pass

    def list_role_policies(self, RoleName: str, Marker: str=None, MaxItems: int=None) -> ListRolePoliciesResponse:
        pass

    def list_role_tags(self, RoleName: str, Marker: str=None, MaxItems: int=None) -> ListRoleTagsResponse:
        pass

    def list_roles(self, PathPrefix: str=None, Marker: str=None, MaxItems: int=None) -> ListRolesResponse:
        pass

    def list_saml_providers(self) -> ListSAMLProvidersResponse:
        pass

    def list_ssh_public_keys(self, UserName: str=None, Marker: str=None, MaxItems: int=None) -> ListSSHPublicKeysResponse:
        pass

    def list_server_certificates(self, PathPrefix: str=None, Marker: str=None, MaxItems: int=None) -> ListServerCertificatesResponse:
        pass

    def list_service_specific_credentials(self, UserName: str=None, ServiceName: str=None) -> ListServiceSpecificCredentialsResponse:
        pass

    def list_signing_certificates(self, UserName: str=None, Marker: str=None, MaxItems: int=None) -> ListSigningCertificatesResponse:
        pass

    def list_user_policies(self, UserName: str, Marker: str=None, MaxItems: int=None) -> ListUserPoliciesResponse:
        pass

    def list_user_tags(self, UserName: str, Marker: str=None, MaxItems: int=None) -> ListUserTagsResponse:
        pass

    def list_users(self, PathPrefix: str=None, Marker: str=None, MaxItems: int=None) -> ListUsersResponse:
        pass

    def list_virtual_mfa_devices(self, AssignmentStatus: str=None, Marker: str=None, MaxItems: int=None) -> ListVirtualMFADevicesResponse:
        pass

    def put_group_policy(self, PolicyDocument: str, PolicyName: str, GroupName: str):
        pass

    def put_role_permissions_boundary(self, PermissionsBoundary: str, RoleName: str):
        pass

    def put_role_policy(self, PolicyDocument: str, PolicyName: str, RoleName: str):
        pass

    def put_user_permissions_boundary(self, PermissionsBoundary: str, UserName: str):
        pass

    def put_user_policy(self, PolicyDocument: str, PolicyName: str, UserName: str):
        pass

    def remove_client_id_from_open_id_connect_provider(self, ClientID: str, OpenIDConnectProviderArn: str):
        pass

    def remove_role_from_instance_profile(self, RoleName: str, InstanceProfileName: str):
        pass

    def remove_user_from_group(self, UserName: str, GroupName: str):
        pass

    def reset_service_specific_credential(self, ServiceSpecificCredentialId: str, UserName: str=None) -> ResetServiceSpecificCredentialResponse:
        pass

    def resync_mfa_device(self, AuthenticationCode2: str, AuthenticationCode1: str, SerialNumber: str, UserName: str):
        pass

    def set_default_policy_version(self, VersionId: str, PolicyArn: str):
        pass

    def simulate_custom_policy(self, ActionNames: List[ActionNameType], PolicyInputList: List[policyDocumentType], ResourceArns: List[ResourceNameType]=None, ResourcePolicy: str=None, ResourceOwner: str=None, CallerArn: str=None, ContextEntries: List[ContextEntry]=None, ResourceHandlingOption: str=None, MaxItems: int=None, Marker: str=None) -> SimulatePolicyResponse:
        pass

    def simulate_principal_policy(self, ActionNames: List[ActionNameType], PolicySourceArn: str, PolicyInputList: List[policyDocumentType]=None, ResourceArns: List[ResourceNameType]=None, ResourcePolicy: str=None, ResourceOwner: str=None, CallerArn: str=None, ContextEntries: List[ContextEntry]=None, ResourceHandlingOption: str=None, MaxItems: int=None, Marker: str=None) -> SimulatePolicyResponse:
        pass

    def tag_role(self, Tags: List[Tag], RoleName: str):
        pass

    def tag_user(self, Tags: List[Tag], UserName: str):
        pass

    def untag_role(self, TagKeys: List[tagKeyType], RoleName: str):
        pass

    def untag_user(self, TagKeys: List[tagKeyType], UserName: str):
        pass

    def update_access_key(self, Status: str, AccessKeyId: str, UserName: str=None):
        pass

    def update_account_password_policy(self, MinimumPasswordLength: int=None, RequireSymbols: booleanType=None, RequireNumbers: booleanType=None, RequireUppercaseCharacters: booleanType=None, RequireLowercaseCharacters: booleanType=None, AllowUsersToChangePassword: booleanType=None, MaxPasswordAge: int=None, PasswordReusePrevention: int=None, HardExpiry: booleanObjectType=None):
        pass

    def update_assume_role_policy(self, PolicyDocument: str, RoleName: str):
        pass

    def update_group(self, GroupName: str, NewPath: str=None, NewGroupName: str=None):
        pass

    def update_login_profile(self, UserName: str, Password: str=None, PasswordResetRequired: booleanObjectType=None):
        pass

    def update_open_id_connect_provider_thumbprint(self, ThumbprintList: List[thumbprintType], OpenIDConnectProviderArn: str):
        pass

    def update_role(self, RoleName: str, Description: str=None, MaxSessionDuration: int=None) -> UpdateRoleResponse:
        pass

    def update_role_description(self, Description: str, RoleName: str) -> UpdateRoleDescriptionResponse:
        pass

    def update_saml_provider(self, SAMLProviderArn: str, SAMLMetadataDocument: str) -> UpdateSAMLProviderResponse:
        pass

    def update_ssh_public_key(self, Status: str, SSHPublicKeyId: str, UserName: str):
        pass

    def update_server_certificate(self, ServerCertificateName: str, NewPath: str=None, NewServerCertificateName: str=None):
        pass

    def update_service_specific_credential(self, Status: str, ServiceSpecificCredentialId: str, UserName: str=None):
        pass

    def update_signing_certificate(self, Status: str, CertificateId: str, UserName: str=None):
        pass

    def update_user(self, UserName: str, NewPath: str=None, NewUserName: str=None):
        pass

    def upload_ssh_public_key(self, SSHPublicKeyBody: str, UserName: str) -> UploadSSHPublicKeyResponse:
        pass

    def upload_server_certificate(self, PrivateKey: str, CertificateBody: str, ServerCertificateName: str, Path: str=None, CertificateChain: str=None) -> UploadServerCertificateResponse:
        pass

    def upload_signing_certificate(self, CertificateBody: str, UserName: str=None) -> UploadSigningCertificateResponse:
        pass


class ImportExport(BaseClient):
    class CancelJobInput(Mapping):
        pass

    class CancelJobOutput(Mapping):
        pass

    class CreateJobInput(Mapping):
        pass

    class CreateJobOutput(Mapping):
        pass

    class ValidateOnly(object):
        pass

    class GetShippingLabelInput(Mapping):
        pass

    class GetShippingLabelOutput(Mapping):
        pass

    class GenericString(object):
        pass

    class GetStatusInput(Mapping):
        pass

    class GetStatusOutput(Mapping):
        pass

    class ListJobsInput(Mapping):
        pass

    class ListJobsOutput(Mapping):
        pass

    class UpdateJobInput(Mapping):
        pass

    class UpdateJobOutput(Mapping):
        pass

    def cancel_job(self, JobId: str, APIVersion: str=None) -> CancelJobOutput:
        pass

    def create_job(self, ValidateOnly: ValidateOnly, Manifest: str, JobType: str, ManifestAddendum: str=None, APIVersion: str=None) -> CreateJobOutput:
        pass

    def get_shipping_label(self, jobIds: List[GenericString], name: str=None, company: str=None, phoneNumber: str=None, country: str=None, stateOrProvince: str=None, city: str=None, postalCode: str=None, street1: str=None, street2: str=None, street3: str=None, APIVersion: str=None) -> GetShippingLabelOutput:
        pass

    def get_status(self, JobId: str, APIVersion: str=None) -> GetStatusOutput:
        pass

    def list_jobs(self, MaxJobs: int=None, Marker: str=None, APIVersion: str=None) -> ListJobsOutput:
        pass

    def update_job(self, ValidateOnly: ValidateOnly, JobType: str, Manifest: str, JobId: str, APIVersion: str=None) -> UpdateJobOutput:
        pass


class Inspector(BaseClient):
    class AddAttributesToFindingsRequest(Mapping):
        pass

    class AddAttributesToFindingsResponse(Mapping):
        pass

    class Arn(object):
        pass

    class Attribute(Mapping):
        pass

    class CreateAssessmentTargetRequest(Mapping):
        pass

    class CreateAssessmentTargetResponse(Mapping):
        pass

    class CreateAssessmentTemplateRequest(Mapping):
        pass

    class CreateAssessmentTemplateResponse(Mapping):
        pass

    class CreateExclusionsPreviewRequest(Mapping):
        pass

    class CreateExclusionsPreviewResponse(Mapping):
        pass

    class CreateResourceGroupRequest(Mapping):
        pass

    class CreateResourceGroupResponse(Mapping):
        pass

    class ResourceGroupTag(Mapping):
        pass

    class DeleteAssessmentRunRequest(Mapping):
        pass

    class DeleteAssessmentTargetRequest(Mapping):
        pass

    class DeleteAssessmentTemplateRequest(Mapping):
        pass

    class DescribeAssessmentRunsRequest(Mapping):
        pass

    class DescribeAssessmentRunsResponse(Mapping):
        pass

    class DescribeAssessmentTargetsRequest(Mapping):
        pass

    class DescribeAssessmentTargetsResponse(Mapping):
        pass

    class DescribeAssessmentTemplatesRequest(Mapping):
        pass

    class DescribeAssessmentTemplatesResponse(Mapping):
        pass

    class DescribeCrossAccountAccessRoleResponse(Mapping):
        pass

    class DescribeExclusionsRequest(Mapping):
        pass

    class DescribeExclusionsResponse(Mapping):
        pass

    class DescribeFindingsRequest(Mapping):
        pass

    class DescribeFindingsResponse(Mapping):
        pass

    class DescribeResourceGroupsRequest(Mapping):
        pass

    class DescribeResourceGroupsResponse(Mapping):
        pass

    class DescribeRulesPackagesRequest(Mapping):
        pass

    class DescribeRulesPackagesResponse(Mapping):
        pass

    class GetAssessmentReportRequest(Mapping):
        pass

    class GetAssessmentReportResponse(Mapping):
        pass

    class GetExclusionsPreviewRequest(Mapping):
        pass

    class GetExclusionsPreviewResponse(Mapping):
        pass

    class GetTelemetryMetadataRequest(Mapping):
        pass

    class GetTelemetryMetadataResponse(Mapping):
        pass

    class ListAssessmentRunAgentsRequest(Mapping):
        pass

    class ListAssessmentRunAgentsResponse(Mapping):
        pass

    class AgentFilter(Mapping):
        pass

    class ListAssessmentRunsRequest(Mapping):
        pass

    class ListAssessmentRunsResponse(Mapping):
        pass

    class AssessmentRunFilter(Mapping):
        pass

    class ListAssessmentTargetsRequest(Mapping):
        pass

    class ListAssessmentTargetsResponse(Mapping):
        pass

    class AssessmentTargetFilter(Mapping):
        pass

    class ListAssessmentTemplatesRequest(Mapping):
        pass

    class ListAssessmentTemplatesResponse(Mapping):
        pass

    class AssessmentTemplateFilter(Mapping):
        pass

    class ListEventSubscriptionsRequest(Mapping):
        pass

    class ListEventSubscriptionsResponse(Mapping):
        pass

    class ListExclusionsRequest(Mapping):
        pass

    class ListExclusionsResponse(Mapping):
        pass

    class ListFindingsRequest(Mapping):
        pass

    class ListFindingsResponse(Mapping):
        pass

    class FindingFilter(Mapping):
        pass

    class ListRulesPackagesRequest(Mapping):
        pass

    class ListRulesPackagesResponse(Mapping):
        pass

    class ListTagsForResourceRequest(Mapping):
        pass

    class ListTagsForResourceResponse(Mapping):
        pass

    class PreviewAgentsRequest(Mapping):
        pass

    class PreviewAgentsResponse(Mapping):
        pass

    class RegisterCrossAccountAccessRoleRequest(Mapping):
        pass

    class RemoveAttributesFromFindingsRequest(Mapping):
        pass

    class RemoveAttributesFromFindingsResponse(Mapping):
        pass

    class AttributeKey(object):
        pass

    class SetTagsForResourceRequest(Mapping):
        pass

    class Tag(Mapping):
        pass

    class StartAssessmentRunRequest(Mapping):
        pass

    class StartAssessmentRunResponse(Mapping):
        pass

    class StopAssessmentRunRequest(Mapping):
        pass

    class SubscribeToEventRequest(Mapping):
        pass

    class UnsubscribeFromEventRequest(Mapping):
        pass

    class UpdateAssessmentTargetRequest(Mapping):
        pass

    def add_attributes_to_findings(self, attributes: List[Attribute], findingArns: List[Arn]) -> AddAttributesToFindingsResponse:
        pass

    def create_assessment_target(self, assessmentTargetName: str, resourceGroupArn: str=None) -> CreateAssessmentTargetResponse:
        pass

    def create_assessment_template(self, rulesPackageArns: List[Arn], durationInSeconds: int, assessmentTemplateName: str, assessmentTargetArn: str, userAttributesForFindings: List[Attribute]=None) -> CreateAssessmentTemplateResponse:
        pass

    def create_exclusions_preview(self, assessmentTemplateArn: str) -> CreateExclusionsPreviewResponse:
        pass

    def create_resource_group(self, resourceGroupTags: List[ResourceGroupTag]) -> CreateResourceGroupResponse:
        pass

    def delete_assessment_run(self, assessmentRunArn: str):
        pass

    def delete_assessment_target(self, assessmentTargetArn: str):
        pass

    def delete_assessment_template(self, assessmentTemplateArn: str):
        pass

    def describe_assessment_runs(self, assessmentRunArns: List[Arn]) -> DescribeAssessmentRunsResponse:
        pass

    def describe_assessment_targets(self, assessmentTargetArns: List[Arn]) -> DescribeAssessmentTargetsResponse:
        pass

    def describe_assessment_templates(self, assessmentTemplateArns: List[Arn]) -> DescribeAssessmentTemplatesResponse:
        pass

    def describe_cross_account_access_role(self) -> DescribeCrossAccountAccessRoleResponse:
        pass

    def describe_exclusions(self, exclusionArns: List[Arn], locale: str=None) -> DescribeExclusionsResponse:
        pass

    def describe_findings(self, findingArns: List[Arn], locale: str=None) -> DescribeFindingsResponse:
        pass

    def describe_resource_groups(self, resourceGroupArns: List[Arn]) -> DescribeResourceGroupsResponse:
        pass

    def describe_rules_packages(self, rulesPackageArns: List[Arn], locale: str=None) -> DescribeRulesPackagesResponse:
        pass

    def get_assessment_report(self, reportType: str, reportFileFormat: str, assessmentRunArn: str) -> GetAssessmentReportResponse:
        pass

    def get_exclusions_preview(self, previewToken: str, assessmentTemplateArn: str, nextToken: str=None, maxResults: int=None, locale: str=None) -> GetExclusionsPreviewResponse:
        pass

    def get_telemetry_metadata(self, assessmentRunArn: str) -> GetTelemetryMetadataResponse:
        pass

    def list_assessment_run_agents(self, assessmentRunArn: str, filter: AgentFilter=None, nextToken: str=None, maxResults: int=None) -> ListAssessmentRunAgentsResponse:
        pass

    def list_assessment_runs(self, assessmentTemplateArns: List[Arn]=None, filter: AssessmentRunFilter=None, nextToken: str=None, maxResults: int=None) -> ListAssessmentRunsResponse:
        pass

    def list_assessment_targets(self, filter: AssessmentTargetFilter=None, nextToken: str=None, maxResults: int=None) -> ListAssessmentTargetsResponse:
        pass

    def list_assessment_templates(self, assessmentTargetArns: List[Arn]=None, filter: AssessmentTemplateFilter=None, nextToken: str=None, maxResults: int=None) -> ListAssessmentTemplatesResponse:
        pass

    def list_event_subscriptions(self, resourceArn: str=None, nextToken: str=None, maxResults: int=None) -> ListEventSubscriptionsResponse:
        pass

    def list_exclusions(self, assessmentRunArn: str, nextToken: str=None, maxResults: int=None) -> ListExclusionsResponse:
        pass

    def list_findings(self, assessmentRunArns: List[Arn]=None, filter: FindingFilter=None, nextToken: str=None, maxResults: int=None) -> ListFindingsResponse:
        pass

    def list_rules_packages(self, nextToken: str=None, maxResults: int=None) -> ListRulesPackagesResponse:
        pass

    def list_tags_for_resource(self, resourceArn: str) -> ListTagsForResourceResponse:
        pass

    def preview_agents(self, previewAgentsArn: str, nextToken: str=None, maxResults: int=None) -> PreviewAgentsResponse:
        pass

    def register_cross_account_access_role(self, roleArn: str):
        pass

    def remove_attributes_from_findings(self, attributeKeys: List[AttributeKey], findingArns: List[Arn]) -> RemoveAttributesFromFindingsResponse:
        pass

    def set_tags_for_resource(self, resourceArn: str, tags: List[Tag]=None):
        pass

    def start_assessment_run(self, assessmentTemplateArn: str, assessmentRunName: str=None) -> StartAssessmentRunResponse:
        pass

    def stop_assessment_run(self, assessmentRunArn: str, stopAction: str=None):
        pass

    def subscribe_to_event(self, topicArn: str, event: str, resourceArn: str):
        pass

    def unsubscribe_from_event(self, topicArn: str, event: str, resourceArn: str):
        pass

    def update_assessment_target(self, assessmentTargetName: str, assessmentTargetArn: str, resourceGroupArn: str=None):
        pass


class IoT(BaseClient):
    class AcceptCertificateTransferRequest(Mapping):
        pass

    class SetAsActive(object):
        pass

    class AddThingToBillingGroupRequest(Mapping):
        pass

    class AddThingToBillingGroupResponse(Mapping):
        pass

    class AddThingToThingGroupRequest(Mapping):
        pass

    class AddThingToThingGroupResponse(Mapping):
        pass

    class OverrideDynamicGroups(object):
        pass

    class AssociateTargetsWithJobRequest(Mapping):
        pass

    class AssociateTargetsWithJobResponse(Mapping):
        pass

    class TargetArn(object):
        pass

    class AttachPolicyRequest(Mapping):
        pass

    class AttachPrincipalPolicyRequest(Mapping):
        pass

    class AttachSecurityProfileRequest(Mapping):
        pass

    class AttachSecurityProfileResponse(Mapping):
        pass

    class AttachThingPrincipalRequest(Mapping):
        pass

    class AttachThingPrincipalResponse(Mapping):
        pass

    class CancelAuditTaskRequest(Mapping):
        pass

    class CancelAuditTaskResponse(Mapping):
        pass

    class CancelCertificateTransferRequest(Mapping):
        pass

    class CancelJobRequest(Mapping):
        pass

    class CancelJobResponse(Mapping):
        pass

    class ForceFlag(object):
        pass

    class CancelJobExecutionRequest(Mapping):
        pass

    class ExpectedVersion(object):
        pass

    class DetailsMap(object):
        pass

    class ClearDefaultAuthorizerRequest(Mapping):
        pass

    class ClearDefaultAuthorizerResponse(Mapping):
        pass

    class CreateAuthorizerRequest(Mapping):
        pass

    class CreateAuthorizerResponse(Mapping):
        pass

    class PublicKeyMap(object):
        pass

    class CreateBillingGroupRequest(Mapping):
        pass

    class CreateBillingGroupResponse(Mapping):
        pass

    class BillingGroupProperties(Mapping):
        pass

    class Tag(Mapping):
        pass

    class CreateCertificateFromCsrRequest(Mapping):
        pass

    class CreateCertificateFromCsrResponse(Mapping):
        pass

    class CreateDynamicThingGroupRequest(Mapping):
        pass

    class CreateDynamicThingGroupResponse(Mapping):
        pass

    class ThingGroupProperties(Mapping):
        pass

    class CreateJobRequest(Mapping):
        pass

    class CreateJobResponse(Mapping):
        pass

    class PresignedUrlConfig(Mapping):
        pass

    class JobExecutionsRolloutConfig(Mapping):
        pass

    class AbortConfig(Mapping):
        pass

    class TimeoutConfig(Mapping):
        pass

    class CreateKeysAndCertificateRequest(Mapping):
        pass

    class CreateKeysAndCertificateResponse(Mapping):
        pass

    class CreateOTAUpdateRequest(Mapping):
        pass

    class CreateOTAUpdateResponse(Mapping):
        pass

    class Target(object):
        pass

    class AwsJobExecutionsRolloutConfig(Mapping):
        pass

    class OTAUpdateFile(Mapping):
        pass

    class AdditionalParameterMap(object):
        pass

    class CreatePolicyRequest(Mapping):
        pass

    class CreatePolicyResponse(Mapping):
        pass

    class CreatePolicyVersionRequest(Mapping):
        pass

    class CreatePolicyVersionResponse(Mapping):
        pass

    class SetAsDefault(object):
        pass

    class CreateRoleAliasRequest(Mapping):
        pass

    class CreateRoleAliasResponse(Mapping):
        pass

    class CreateScheduledAuditRequest(Mapping):
        pass

    class CreateScheduledAuditResponse(Mapping):
        pass

    class AuditCheckName(object):
        pass

    class CreateSecurityProfileRequest(Mapping):
        pass

    class CreateSecurityProfileResponse(Mapping):
        pass

    class Behavior(Mapping):
        pass

    class AlertTargets(object):
        pass

    class CreateStreamRequest(Mapping):
        pass

    class CreateStreamResponse(Mapping):
        pass

    class StreamFile(Mapping):
        pass

    class CreateThingRequest(Mapping):
        pass

    class CreateThingResponse(Mapping):
        pass

    class AttributePayload(Mapping):
        pass

    class CreateThingGroupRequest(Mapping):
        pass

    class CreateThingGroupResponse(Mapping):
        pass

    class CreateThingTypeRequest(Mapping):
        pass

    class CreateThingTypeResponse(Mapping):
        pass

    class ThingTypeProperties(Mapping):
        pass

    class CreateTopicRuleRequest(Mapping):
        pass

    class TopicRulePayload(Mapping):
        pass

    class DeleteAccountAuditConfigurationRequest(Mapping):
        pass

    class DeleteAccountAuditConfigurationResponse(Mapping):
        pass

    class DeleteScheduledAudits(object):
        pass

    class DeleteAuthorizerRequest(Mapping):
        pass

    class DeleteAuthorizerResponse(Mapping):
        pass

    class DeleteBillingGroupRequest(Mapping):
        pass

    class DeleteBillingGroupResponse(Mapping):
        pass

    class OptionalVersion(object):
        pass

    class DeleteCACertificateRequest(Mapping):
        pass

    class DeleteCACertificateResponse(Mapping):
        pass

    class DeleteCertificateRequest(Mapping):
        pass

    class ForceDelete(object):
        pass

    class DeleteDynamicThingGroupRequest(Mapping):
        pass

    class DeleteDynamicThingGroupResponse(Mapping):
        pass

    class DeleteJobRequest(Mapping):
        pass

    class DeleteJobExecutionRequest(Mapping):
        pass

    class ExecutionNumber(object):
        pass

    class DeleteOTAUpdateRequest(Mapping):
        pass

    class DeleteOTAUpdateResponse(Mapping):
        pass

    class DeleteStream(object):
        pass

    class ForceDeleteAWSJob(object):
        pass

    class DeletePolicyRequest(Mapping):
        pass

    class DeletePolicyVersionRequest(Mapping):
        pass

    class DeleteRegistrationCodeRequest(Mapping):
        pass

    class DeleteRegistrationCodeResponse(Mapping):
        pass

    class DeleteRoleAliasRequest(Mapping):
        pass

    class DeleteRoleAliasResponse(Mapping):
        pass

    class DeleteScheduledAuditRequest(Mapping):
        pass

    class DeleteScheduledAuditResponse(Mapping):
        pass

    class DeleteSecurityProfileRequest(Mapping):
        pass

    class DeleteSecurityProfileResponse(Mapping):
        pass

    class DeleteStreamRequest(Mapping):
        pass

    class DeleteStreamResponse(Mapping):
        pass

    class DeleteThingRequest(Mapping):
        pass

    class DeleteThingResponse(Mapping):
        pass

    class DeleteThingGroupRequest(Mapping):
        pass

    class DeleteThingGroupResponse(Mapping):
        pass

    class DeleteThingTypeRequest(Mapping):
        pass

    class DeleteThingTypeResponse(Mapping):
        pass

    class DeleteTopicRuleRequest(Mapping):
        pass

    class DeleteV2LoggingLevelRequest(Mapping):
        pass

    class DeprecateThingTypeRequest(Mapping):
        pass

    class DeprecateThingTypeResponse(Mapping):
        pass

    class UndoDeprecate(object):
        pass

    class DescribeAccountAuditConfigurationRequest(Mapping):
        pass

    class DescribeAccountAuditConfigurationResponse(Mapping):
        pass

    class DescribeAuditTaskRequest(Mapping):
        pass

    class DescribeAuditTaskResponse(Mapping):
        pass

    class DescribeAuthorizerRequest(Mapping):
        pass

    class DescribeAuthorizerResponse(Mapping):
        pass

    class DescribeBillingGroupRequest(Mapping):
        pass

    class DescribeBillingGroupResponse(Mapping):
        pass

    class DescribeCACertificateRequest(Mapping):
        pass

    class DescribeCACertificateResponse(Mapping):
        pass

    class DescribeCertificateRequest(Mapping):
        pass

    class DescribeCertificateResponse(Mapping):
        pass

    class DescribeDefaultAuthorizerRequest(Mapping):
        pass

    class DescribeDefaultAuthorizerResponse(Mapping):
        pass

    class DescribeEndpointRequest(Mapping):
        pass

    class DescribeEndpointResponse(Mapping):
        pass

    class DescribeEventConfigurationsRequest(Mapping):
        pass

    class DescribeEventConfigurationsResponse(Mapping):
        pass

    class DescribeIndexRequest(Mapping):
        pass

    class DescribeIndexResponse(Mapping):
        pass

    class DescribeJobRequest(Mapping):
        pass

    class DescribeJobResponse(Mapping):
        pass

    class DescribeJobExecutionRequest(Mapping):
        pass

    class DescribeJobExecutionResponse(Mapping):
        pass

    class DescribeRoleAliasRequest(Mapping):
        pass

    class DescribeRoleAliasResponse(Mapping):
        pass

    class DescribeScheduledAuditRequest(Mapping):
        pass

    class DescribeScheduledAuditResponse(Mapping):
        pass

    class DescribeSecurityProfileRequest(Mapping):
        pass

    class DescribeSecurityProfileResponse(Mapping):
        pass

    class DescribeStreamRequest(Mapping):
        pass

    class DescribeStreamResponse(Mapping):
        pass

    class DescribeThingRequest(Mapping):
        pass

    class DescribeThingResponse(Mapping):
        pass

    class DescribeThingGroupRequest(Mapping):
        pass

    class DescribeThingGroupResponse(Mapping):
        pass

    class DescribeThingRegistrationTaskRequest(Mapping):
        pass

    class DescribeThingRegistrationTaskResponse(Mapping):
        pass

    class DescribeThingTypeRequest(Mapping):
        pass

    class DescribeThingTypeResponse(Mapping):
        pass

    class DetachPolicyRequest(Mapping):
        pass

    class DetachPrincipalPolicyRequest(Mapping):
        pass

    class DetachSecurityProfileRequest(Mapping):
        pass

    class DetachSecurityProfileResponse(Mapping):
        pass

    class DetachThingPrincipalRequest(Mapping):
        pass

    class DetachThingPrincipalResponse(Mapping):
        pass

    class DisableTopicRuleRequest(Mapping):
        pass

    class EnableTopicRuleRequest(Mapping):
        pass

    class GetEffectivePoliciesRequest(Mapping):
        pass

    class GetEffectivePoliciesResponse(Mapping):
        pass

    class GetIndexingConfigurationRequest(Mapping):
        pass

    class GetIndexingConfigurationResponse(Mapping):
        pass

    class GetJobDocumentRequest(Mapping):
        pass

    class GetJobDocumentResponse(Mapping):
        pass

    class GetLoggingOptionsRequest(Mapping):
        pass

    class GetLoggingOptionsResponse(Mapping):
        pass

    class GetOTAUpdateRequest(Mapping):
        pass

    class GetOTAUpdateResponse(Mapping):
        pass

    class GetPolicyRequest(Mapping):
        pass

    class GetPolicyResponse(Mapping):
        pass

    class GetPolicyVersionRequest(Mapping):
        pass

    class GetPolicyVersionResponse(Mapping):
        pass

    class GetRegistrationCodeRequest(Mapping):
        pass

    class GetRegistrationCodeResponse(Mapping):
        pass

    class GetTopicRuleRequest(Mapping):
        pass

    class GetTopicRuleResponse(Mapping):
        pass

    class GetV2LoggingOptionsRequest(Mapping):
        pass

    class GetV2LoggingOptionsResponse(Mapping):
        pass

    class ListActiveViolationsRequest(Mapping):
        pass

    class ListActiveViolationsResponse(Mapping):
        pass

    class ListAttachedPoliciesRequest(Mapping):
        pass

    class ListAttachedPoliciesResponse(Mapping):
        pass

    class Recursive(object):
        pass

    class ListAuditFindingsRequest(Mapping):
        pass

    class ListAuditFindingsResponse(Mapping):
        pass

    class ResourceIdentifier(Mapping):
        pass

    class Timestamp(object):
        pass

    class ListAuditTasksRequest(Mapping):
        pass

    class ListAuditTasksResponse(Mapping):
        pass

    class ListAuthorizersRequest(Mapping):
        pass

    class ListAuthorizersResponse(Mapping):
        pass

    class AscendingOrder(object):
        pass

    class ListBillingGroupsRequest(Mapping):
        pass

    class ListBillingGroupsResponse(Mapping):
        pass

    class ListCACertificatesRequest(Mapping):
        pass

    class ListCACertificatesResponse(Mapping):
        pass

    class ListCertificatesRequest(Mapping):
        pass

    class ListCertificatesResponse(Mapping):
        pass

    class ListCertificatesByCARequest(Mapping):
        pass

    class ListCertificatesByCAResponse(Mapping):
        pass

    class ListIndicesRequest(Mapping):
        pass

    class ListIndicesResponse(Mapping):
        pass

    class ListJobExecutionsForJobRequest(Mapping):
        pass

    class ListJobExecutionsForJobResponse(Mapping):
        pass

    class ListJobExecutionsForThingRequest(Mapping):
        pass

    class ListJobExecutionsForThingResponse(Mapping):
        pass

    class ListJobsRequest(Mapping):
        pass

    class ListJobsResponse(Mapping):
        pass

    class ListOTAUpdatesRequest(Mapping):
        pass

    class ListOTAUpdatesResponse(Mapping):
        pass

    class ListOutgoingCertificatesRequest(Mapping):
        pass

    class ListOutgoingCertificatesResponse(Mapping):
        pass

    class ListPoliciesRequest(Mapping):
        pass

    class ListPoliciesResponse(Mapping):
        pass

    class ListPolicyPrincipalsRequest(Mapping):
        pass

    class ListPolicyPrincipalsResponse(Mapping):
        pass

    class ListPolicyVersionsRequest(Mapping):
        pass

    class ListPolicyVersionsResponse(Mapping):
        pass

    class ListPrincipalPoliciesRequest(Mapping):
        pass

    class ListPrincipalPoliciesResponse(Mapping):
        pass

    class ListPrincipalThingsRequest(Mapping):
        pass

    class ListPrincipalThingsResponse(Mapping):
        pass

    class ListRoleAliasesRequest(Mapping):
        pass

    class ListRoleAliasesResponse(Mapping):
        pass

    class ListScheduledAuditsRequest(Mapping):
        pass

    class ListScheduledAuditsResponse(Mapping):
        pass

    class ListSecurityProfilesRequest(Mapping):
        pass

    class ListSecurityProfilesResponse(Mapping):
        pass

    class ListSecurityProfilesForTargetRequest(Mapping):
        pass

    class ListSecurityProfilesForTargetResponse(Mapping):
        pass

    class ListStreamsRequest(Mapping):
        pass

    class ListStreamsResponse(Mapping):
        pass

    class ListTagsForResourceRequest(Mapping):
        pass

    class ListTagsForResourceResponse(Mapping):
        pass

    class ListTargetsForPolicyRequest(Mapping):
        pass

    class ListTargetsForPolicyResponse(Mapping):
        pass

    class ListTargetsForSecurityProfileRequest(Mapping):
        pass

    class ListTargetsForSecurityProfileResponse(Mapping):
        pass

    class ListThingGroupsRequest(Mapping):
        pass

    class ListThingGroupsResponse(Mapping):
        pass

    class RecursiveWithoutDefault(object):
        pass

    class ListThingGroupsForThingRequest(Mapping):
        pass

    class ListThingGroupsForThingResponse(Mapping):
        pass

    class ListThingPrincipalsRequest(Mapping):
        pass

    class ListThingPrincipalsResponse(Mapping):
        pass

    class ListThingRegistrationTaskReportsRequest(Mapping):
        pass

    class ListThingRegistrationTaskReportsResponse(Mapping):
        pass

    class ListThingRegistrationTasksRequest(Mapping):
        pass

    class ListThingRegistrationTasksResponse(Mapping):
        pass

    class ListThingTypesRequest(Mapping):
        pass

    class ListThingTypesResponse(Mapping):
        pass

    class ListThingsRequest(Mapping):
        pass

    class ListThingsResponse(Mapping):
        pass

    class ListThingsInBillingGroupRequest(Mapping):
        pass

    class ListThingsInBillingGroupResponse(Mapping):
        pass

    class ListThingsInThingGroupRequest(Mapping):
        pass

    class ListThingsInThingGroupResponse(Mapping):
        pass

    class ListTopicRulesRequest(Mapping):
        pass

    class ListTopicRulesResponse(Mapping):
        pass

    class IsDisabled(object):
        pass

    class ListV2LoggingLevelsRequest(Mapping):
        pass

    class ListV2LoggingLevelsResponse(Mapping):
        pass

    class ListViolationEventsRequest(Mapping):
        pass

    class ListViolationEventsResponse(Mapping):
        pass

    class RegisterCACertificateRequest(Mapping):
        pass

    class RegisterCACertificateResponse(Mapping):
        pass

    class AllowAutoRegistration(object):
        pass

    class RegistrationConfig(Mapping):
        pass

    class RegisterCertificateRequest(Mapping):
        pass

    class RegisterCertificateResponse(Mapping):
        pass

    class SetAsActiveFlag(object):
        pass

    class RegisterThingRequest(Mapping):
        pass

    class RegisterThingResponse(Mapping):
        pass

    class Parameters(object):
        pass

    class RejectCertificateTransferRequest(Mapping):
        pass

    class RemoveThingFromBillingGroupRequest(Mapping):
        pass

    class RemoveThingFromBillingGroupResponse(Mapping):
        pass

    class RemoveThingFromThingGroupRequest(Mapping):
        pass

    class RemoveThingFromThingGroupResponse(Mapping):
        pass

    class ReplaceTopicRuleRequest(Mapping):
        pass

    class SearchIndexRequest(Mapping):
        pass

    class SearchIndexResponse(Mapping):
        pass

    class SetDefaultAuthorizerRequest(Mapping):
        pass

    class SetDefaultAuthorizerResponse(Mapping):
        pass

    class SetDefaultPolicyVersionRequest(Mapping):
        pass

    class SetLoggingOptionsRequest(Mapping):
        pass

    class LoggingOptionsPayload(Mapping):
        pass

    class SetV2LoggingLevelRequest(Mapping):
        pass

    class LogTarget(Mapping):
        pass

    class SetV2LoggingOptionsRequest(Mapping):
        pass

    class DisableAllLogs(object):
        pass

    class StartOnDemandAuditTaskRequest(Mapping):
        pass

    class StartOnDemandAuditTaskResponse(Mapping):
        pass

    class StartThingRegistrationTaskRequest(Mapping):
        pass

    class StartThingRegistrationTaskResponse(Mapping):
        pass

    class StopThingRegistrationTaskRequest(Mapping):
        pass

    class StopThingRegistrationTaskResponse(Mapping):
        pass

    class TagResourceRequest(Mapping):
        pass

    class TagResourceResponse(Mapping):
        pass

    class TestAuthorizationRequest(Mapping):
        pass

    class TestAuthorizationResponse(Mapping):
        pass

    class AuthInfo(Mapping):
        pass

    class PolicyName(object):
        pass

    class TestInvokeAuthorizerRequest(Mapping):
        pass

    class TestInvokeAuthorizerResponse(Mapping):
        pass

    class TransferCertificateRequest(Mapping):
        pass

    class TransferCertificateResponse(Mapping):
        pass

    class UntagResourceRequest(Mapping):
        pass

    class UntagResourceResponse(Mapping):
        pass

    class TagKey(object):
        pass

    class UpdateAccountAuditConfigurationRequest(Mapping):
        pass

    class UpdateAccountAuditConfigurationResponse(Mapping):
        pass

    class AuditNotificationTargetConfigurations(object):
        pass

    class AuditCheckConfigurations(object):
        pass

    class UpdateAuthorizerRequest(Mapping):
        pass

    class UpdateAuthorizerResponse(Mapping):
        pass

    class UpdateBillingGroupRequest(Mapping):
        pass

    class UpdateBillingGroupResponse(Mapping):
        pass

    class UpdateCACertificateRequest(Mapping):
        pass

    class RemoveAutoRegistration(object):
        pass

    class UpdateCertificateRequest(Mapping):
        pass

    class UpdateDynamicThingGroupRequest(Mapping):
        pass

    class UpdateDynamicThingGroupResponse(Mapping):
        pass

    class UpdateEventConfigurationsRequest(Mapping):
        pass

    class UpdateEventConfigurationsResponse(Mapping):
        pass

    class EventConfigurations(object):
        pass

    class UpdateIndexingConfigurationRequest(Mapping):
        pass

    class UpdateIndexingConfigurationResponse(Mapping):
        pass

    class ThingIndexingConfiguration(Mapping):
        pass

    class ThingGroupIndexingConfiguration(Mapping):
        pass

    class UpdateJobRequest(Mapping):
        pass

    class UpdateRoleAliasRequest(Mapping):
        pass

    class UpdateRoleAliasResponse(Mapping):
        pass

    class UpdateScheduledAuditRequest(Mapping):
        pass

    class UpdateScheduledAuditResponse(Mapping):
        pass

    class UpdateSecurityProfileRequest(Mapping):
        pass

    class UpdateSecurityProfileResponse(Mapping):
        pass

    class UpdateStreamRequest(Mapping):
        pass

    class UpdateStreamResponse(Mapping):
        pass

    class UpdateThingRequest(Mapping):
        pass

    class UpdateThingResponse(Mapping):
        pass

    class RemoveThingType(object):
        pass

    class UpdateThingGroupRequest(Mapping):
        pass

    class UpdateThingGroupResponse(Mapping):
        pass

    class UpdateThingGroupsForThingRequest(Mapping):
        pass

    class UpdateThingGroupsForThingResponse(Mapping):
        pass

    class ThingGroupName(object):
        pass

    class ValidateSecurityProfileBehaviorsRequest(Mapping):
        pass

    class ValidateSecurityProfileBehaviorsResponse(Mapping):
        pass

    def accept_certificate_transfer(self, certificateId: str, setAsActive: SetAsActive=None):
        pass

    def add_thing_to_billing_group(self, billingGroupName: str=None, billingGroupArn: str=None, thingName: str=None, thingArn: str=None) -> AddThingToBillingGroupResponse:
        pass

    def add_thing_to_thing_group(self, thingGroupName: str=None, thingGroupArn: str=None, thingName: str=None, thingArn: str=None, overrideDynamicGroups: OverrideDynamicGroups=None) -> AddThingToThingGroupResponse:
        pass

    def associate_targets_with_job(self, jobId: str, targets: List[TargetArn], comment: str=None) -> AssociateTargetsWithJobResponse:
        pass

    def attach_policy(self, target: str, policyName: str):
        pass

    def attach_principal_policy(self, principal: str, policyName: str):
        pass

    def attach_security_profile(self, securityProfileTargetArn: str, securityProfileName: str) -> AttachSecurityProfileResponse:
        pass

    def attach_thing_principal(self, principal: str, thingName: str) -> AttachThingPrincipalResponse:
        pass

    def cancel_audit_task(self, taskId: str) -> CancelAuditTaskResponse:
        pass

    def cancel_certificate_transfer(self, certificateId: str):
        pass

    def cancel_job(self, jobId: str, reasonCode: str=None, comment: str=None, force: ForceFlag=None) -> CancelJobResponse:
        pass

    def cancel_job_execution(self, thingName: str, jobId: str, force: ForceFlag=None, expectedVersion: ExpectedVersion=None, statusDetails: DetailsMap=None):
        pass

    def clear_default_authorizer(self) -> ClearDefaultAuthorizerResponse:
        pass

    def create_authorizer(self, tokenSigningPublicKeys: PublicKeyMap, tokenKeyName: str, authorizerFunctionArn: str, authorizerName: str, status: str=None) -> CreateAuthorizerResponse:
        pass

    def create_billing_group(self, billingGroupName: str, billingGroupProperties: BillingGroupProperties=None, tags: List[Tag]=None) -> CreateBillingGroupResponse:
        pass

    def create_certificate_from_csr(self, certificateSigningRequest: str, setAsActive: SetAsActive=None) -> CreateCertificateFromCsrResponse:
        pass

    def create_dynamic_thing_group(self, queryString: str, thingGroupName: str, thingGroupProperties: ThingGroupProperties=None, indexName: str=None, queryVersion: str=None, tags: List[Tag]=None) -> CreateDynamicThingGroupResponse:
        pass

    def create_job(self, targets: List[TargetArn], jobId: str, documentSource: str=None, document: str=None, description: str=None, presignedUrlConfig: PresignedUrlConfig=None, targetSelection: str=None, jobExecutionsRolloutConfig: JobExecutionsRolloutConfig=None, abortConfig: AbortConfig=None, timeoutConfig: TimeoutConfig=None, tags: List[Tag]=None) -> CreateJobResponse:
        pass

    def create_keys_and_certificate(self, setAsActive: SetAsActive=None) -> CreateKeysAndCertificateResponse:
        pass

    def create_ota_update(self, roleArn: str, files: List[OTAUpdateFile], targets: List[Target], otaUpdateId: str, description: str=None, targetSelection: str=None, awsJobExecutionsRolloutConfig: AwsJobExecutionsRolloutConfig=None, additionalParameters: AdditionalParameterMap=None) -> CreateOTAUpdateResponse:
        pass

    def create_policy(self, policyDocument: str, policyName: str) -> CreatePolicyResponse:
        pass

    def create_policy_version(self, policyDocument: str, policyName: str, setAsDefault: SetAsDefault=None) -> CreatePolicyVersionResponse:
        pass

    def create_role_alias(self, roleArn: str, roleAlias: str, credentialDurationSeconds: int=None) -> CreateRoleAliasResponse:
        pass

    def create_scheduled_audit(self, scheduledAuditName: str, targetCheckNames: List[AuditCheckName], frequency: str, dayOfMonth: str=None, dayOfWeek: str=None) -> CreateScheduledAuditResponse:
        pass

    def create_security_profile(self, behaviors: List[Behavior], securityProfileName: str, securityProfileDescription: str=None, alertTargets: AlertTargets=None, tags: List[Tag]=None) -> CreateSecurityProfileResponse:
        pass

    def create_stream(self, roleArn: str, files: List[StreamFile], streamId: str, description: str=None) -> CreateStreamResponse:
        pass

    def create_thing(self, thingName: str, thingTypeName: str=None, attributePayload: AttributePayload=None, billingGroupName: str=None) -> CreateThingResponse:
        pass

    def create_thing_group(self, thingGroupName: str, parentGroupName: str=None, thingGroupProperties: ThingGroupProperties=None, tags: List[Tag]=None) -> CreateThingGroupResponse:
        pass

    def create_thing_type(self, thingTypeName: str, thingTypeProperties: ThingTypeProperties=None, tags: List[Tag]=None) -> CreateThingTypeResponse:
        pass

    def create_topic_rule(self, topicRulePayload: TopicRulePayload, ruleName: str, tags: str=None):
        pass

    def delete_account_audit_configuration(self, deleteScheduledAudits: DeleteScheduledAudits=None) -> DeleteAccountAuditConfigurationResponse:
        pass

    def delete_authorizer(self, authorizerName: str) -> DeleteAuthorizerResponse:
        pass

    def delete_billing_group(self, billingGroupName: str, expectedVersion: OptionalVersion=None) -> DeleteBillingGroupResponse:
        pass

    def delete_ca_certificate(self, certificateId: str) -> DeleteCACertificateResponse:
        pass

    def delete_certificate(self, certificateId: str, forceDelete: ForceDelete=None):
        pass

    def delete_dynamic_thing_group(self, thingGroupName: str, expectedVersion: OptionalVersion=None) -> DeleteDynamicThingGroupResponse:
        pass

    def delete_job(self, jobId: str, force: ForceFlag=None):
        pass

    def delete_job_execution(self, executionNumber: ExecutionNumber, thingName: str, jobId: str, force: ForceFlag=None):
        pass

    def delete_ota_update(self, otaUpdateId: str, deleteStream: DeleteStream=None, forceDeleteAWSJob: ForceDeleteAWSJob=None) -> DeleteOTAUpdateResponse:
        pass

    def delete_policy(self, policyName: str):
        pass

    def delete_policy_version(self, policyVersionId: str, policyName: str):
        pass

    def delete_registration_code(self) -> DeleteRegistrationCodeResponse:
        pass

    def delete_role_alias(self, roleAlias: str) -> DeleteRoleAliasResponse:
        pass

    def delete_scheduled_audit(self, scheduledAuditName: str) -> DeleteScheduledAuditResponse:
        pass

    def delete_security_profile(self, securityProfileName: str, expectedVersion: OptionalVersion=None) -> DeleteSecurityProfileResponse:
        pass

    def delete_stream(self, streamId: str) -> DeleteStreamResponse:
        pass

    def delete_thing(self, thingName: str, expectedVersion: OptionalVersion=None) -> DeleteThingResponse:
        pass

    def delete_thing_group(self, thingGroupName: str, expectedVersion: OptionalVersion=None) -> DeleteThingGroupResponse:
        pass

    def delete_thing_type(self, thingTypeName: str) -> DeleteThingTypeResponse:
        pass

    def delete_topic_rule(self, ruleName: str):
        pass

    def delete_v2_logging_level(self, targetName: str, targetType: str):
        pass

    def deprecate_thing_type(self, thingTypeName: str, undoDeprecate: UndoDeprecate=None) -> DeprecateThingTypeResponse:
        pass

    def describe_account_audit_configuration(self) -> DescribeAccountAuditConfigurationResponse:
        pass

    def describe_audit_task(self, taskId: str) -> DescribeAuditTaskResponse:
        pass

    def describe_authorizer(self, authorizerName: str) -> DescribeAuthorizerResponse:
        pass

    def describe_billing_group(self, billingGroupName: str) -> DescribeBillingGroupResponse:
        pass

    def describe_ca_certificate(self, certificateId: str) -> DescribeCACertificateResponse:
        pass

    def describe_certificate(self, certificateId: str) -> DescribeCertificateResponse:
        pass

    def describe_default_authorizer(self) -> DescribeDefaultAuthorizerResponse:
        pass

    def describe_endpoint(self, endpointType: str=None) -> DescribeEndpointResponse:
        pass

    def describe_event_configurations(self) -> DescribeEventConfigurationsResponse:
        pass

    def describe_index(self, indexName: str) -> DescribeIndexResponse:
        pass

    def describe_job(self, jobId: str) -> DescribeJobResponse:
        pass

    def describe_job_execution(self, thingName: str, jobId: str, executionNumber: ExecutionNumber=None) -> DescribeJobExecutionResponse:
        pass

    def describe_role_alias(self, roleAlias: str) -> DescribeRoleAliasResponse:
        pass

    def describe_scheduled_audit(self, scheduledAuditName: str) -> DescribeScheduledAuditResponse:
        pass

    def describe_security_profile(self, securityProfileName: str) -> DescribeSecurityProfileResponse:
        pass

    def describe_stream(self, streamId: str) -> DescribeStreamResponse:
        pass

    def describe_thing(self, thingName: str) -> DescribeThingResponse:
        pass

    def describe_thing_group(self, thingGroupName: str) -> DescribeThingGroupResponse:
        pass

    def describe_thing_registration_task(self, taskId: str) -> DescribeThingRegistrationTaskResponse:
        pass

    def describe_thing_type(self, thingTypeName: str) -> DescribeThingTypeResponse:
        pass

    def detach_policy(self, target: str, policyName: str):
        pass

    def detach_principal_policy(self, principal: str, policyName: str):
        pass

    def detach_security_profile(self, securityProfileTargetArn: str, securityProfileName: str) -> DetachSecurityProfileResponse:
        pass

    def detach_thing_principal(self, principal: str, thingName: str) -> DetachThingPrincipalResponse:
        pass

    def disable_topic_rule(self, ruleName: str):
        pass

    def enable_topic_rule(self, ruleName: str):
        pass

    def get_effective_policies(self, principal: str=None, cognitoIdentityPoolId: str=None, thingName: str=None) -> GetEffectivePoliciesResponse:
        pass

    def get_indexing_configuration(self) -> GetIndexingConfigurationResponse:
        pass

    def get_job_document(self, jobId: str) -> GetJobDocumentResponse:
        pass

    def get_logging_options(self) -> GetLoggingOptionsResponse:
        pass

    def get_ota_update(self, otaUpdateId: str) -> GetOTAUpdateResponse:
        pass

    def get_policy(self, policyName: str) -> GetPolicyResponse:
        pass

    def get_policy_version(self, policyVersionId: str, policyName: str) -> GetPolicyVersionResponse:
        pass

    def get_registration_code(self) -> GetRegistrationCodeResponse:
        pass

    def get_topic_rule(self, ruleName: str) -> GetTopicRuleResponse:
        pass

    def get_v2_logging_options(self) -> GetV2LoggingOptionsResponse:
        pass

    def list_active_violations(self, thingName: str=None, securityProfileName: str=None, nextToken: str=None, maxResults: int=None) -> ListActiveViolationsResponse:
        pass

    def list_attached_policies(self, target: str, recursive: Recursive=None, marker: str=None, pageSize: int=None) -> ListAttachedPoliciesResponse:
        pass

    def list_audit_findings(self, taskId: str=None, checkName: str=None, resourceIdentifier: ResourceIdentifier=None, maxResults: int=None, nextToken: str=None, startTime: Timestamp=None, endTime: Timestamp=None) -> ListAuditFindingsResponse:
        pass

    def list_audit_tasks(self, endTime: Timestamp, startTime: Timestamp, taskType: str=None, taskStatus: str=None, nextToken: str=None, maxResults: int=None) -> ListAuditTasksResponse:
        pass

    def list_authorizers(self, pageSize: int=None, marker: str=None, ascendingOrder: AscendingOrder=None, status: str=None) -> ListAuthorizersResponse:
        pass

    def list_billing_groups(self, nextToken: str=None, maxResults: int=None, namePrefixFilter: str=None) -> ListBillingGroupsResponse:
        pass

    def list_ca_certificates(self, pageSize: int=None, marker: str=None, ascendingOrder: AscendingOrder=None) -> ListCACertificatesResponse:
        pass

    def list_certificates(self, pageSize: int=None, marker: str=None, ascendingOrder: AscendingOrder=None) -> ListCertificatesResponse:
        pass

    def list_certificates_by_ca(self, caCertificateId: str, pageSize: int=None, marker: str=None, ascendingOrder: AscendingOrder=None) -> ListCertificatesByCAResponse:
        pass

    def list_indices(self, nextToken: str=None, maxResults: int=None) -> ListIndicesResponse:
        pass

    def list_job_executions_for_job(self, jobId: str, status: str=None, maxResults: int=None, nextToken: str=None) -> ListJobExecutionsForJobResponse:
        pass

    def list_job_executions_for_thing(self, thingName: str, status: str=None, maxResults: int=None, nextToken: str=None) -> ListJobExecutionsForThingResponse:
        pass

    def list_jobs(self, status: str=None, targetSelection: str=None, maxResults: int=None, nextToken: str=None, thingGroupName: str=None, thingGroupId: str=None) -> ListJobsResponse:
        pass

    def list_ota_updates(self, maxResults: int=None, nextToken: str=None, otaUpdateStatus: str=None) -> ListOTAUpdatesResponse:
        pass

    def list_outgoing_certificates(self, pageSize: int=None, marker: str=None, ascendingOrder: AscendingOrder=None) -> ListOutgoingCertificatesResponse:
        pass

    def list_policies(self, marker: str=None, pageSize: int=None, ascendingOrder: AscendingOrder=None) -> ListPoliciesResponse:
        pass

    def list_policy_principals(self, policyName: str, marker: str=None, pageSize: int=None, ascendingOrder: AscendingOrder=None) -> ListPolicyPrincipalsResponse:
        pass

    def list_policy_versions(self, policyName: str) -> ListPolicyVersionsResponse:
        pass

    def list_principal_policies(self, principal: str, marker: str=None, pageSize: int=None, ascendingOrder: AscendingOrder=None) -> ListPrincipalPoliciesResponse:
        pass

    def list_principal_things(self, principal: str, nextToken: str=None, maxResults: int=None) -> ListPrincipalThingsResponse:
        pass

    def list_role_aliases(self, pageSize: int=None, marker: str=None, ascendingOrder: AscendingOrder=None) -> ListRoleAliasesResponse:
        pass

    def list_scheduled_audits(self, nextToken: str=None, maxResults: int=None) -> ListScheduledAuditsResponse:
        pass

    def list_security_profiles(self, nextToken: str=None, maxResults: int=None) -> ListSecurityProfilesResponse:
        pass

    def list_security_profiles_for_target(self, securityProfileTargetArn: str, nextToken: str=None, maxResults: int=None, recursive: Recursive=None) -> ListSecurityProfilesForTargetResponse:
        pass

    def list_streams(self, maxResults: int=None, nextToken: str=None, ascendingOrder: AscendingOrder=None) -> ListStreamsResponse:
        pass

    def list_tags_for_resource(self, resourceArn: str, nextToken: str=None) -> ListTagsForResourceResponse:
        pass

    def list_targets_for_policy(self, policyName: str, marker: str=None, pageSize: int=None) -> ListTargetsForPolicyResponse:
        pass

    def list_targets_for_security_profile(self, securityProfileName: str, nextToken: str=None, maxResults: int=None) -> ListTargetsForSecurityProfileResponse:
        pass

    def list_thing_groups(self, nextToken: str=None, maxResults: int=None, parentGroup: str=None, namePrefixFilter: str=None, recursive: RecursiveWithoutDefault=None) -> ListThingGroupsResponse:
        pass

    def list_thing_groups_for_thing(self, thingName: str, nextToken: str=None, maxResults: int=None) -> ListThingGroupsForThingResponse:
        pass

    def list_thing_principals(self, thingName: str) -> ListThingPrincipalsResponse:
        pass

    def list_thing_registration_task_reports(self, reportType: str, taskId: str, nextToken: str=None, maxResults: int=None) -> ListThingRegistrationTaskReportsResponse:
        pass

    def list_thing_registration_tasks(self, nextToken: str=None, maxResults: int=None, status: str=None) -> ListThingRegistrationTasksResponse:
        pass

    def list_thing_types(self, nextToken: str=None, maxResults: int=None, thingTypeName: str=None) -> ListThingTypesResponse:
        pass

    def list_things(self, nextToken: str=None, maxResults: int=None, attributeName: str=None, attributeValue: str=None, thingTypeName: str=None) -> ListThingsResponse:
        pass

    def list_things_in_billing_group(self, billingGroupName: str, nextToken: str=None, maxResults: int=None) -> ListThingsInBillingGroupResponse:
        pass

    def list_things_in_thing_group(self, thingGroupName: str, recursive: Recursive=None, nextToken: str=None, maxResults: int=None) -> ListThingsInThingGroupResponse:
        pass

    def list_topic_rules(self, topic: str=None, maxResults: int=None, nextToken: str=None, ruleDisabled: IsDisabled=None) -> ListTopicRulesResponse:
        pass

    def list_v2_logging_levels(self, targetType: str=None, nextToken: str=None, maxResults: int=None) -> ListV2LoggingLevelsResponse:
        pass

    def list_violation_events(self, endTime: Timestamp, startTime: Timestamp, thingName: str=None, securityProfileName: str=None, nextToken: str=None, maxResults: int=None) -> ListViolationEventsResponse:
        pass

    def register_ca_certificate(self, verificationCertificate: str, caCertificate: str, setAsActive: SetAsActive=None, allowAutoRegistration: AllowAutoRegistration=None, registrationConfig: RegistrationConfig=None) -> RegisterCACertificateResponse:
        pass

    def register_certificate(self, certificatePem: str, caCertificatePem: str=None, setAsActive: SetAsActiveFlag=None, status: str=None) -> RegisterCertificateResponse:
        pass

    def register_thing(self, templateBody: str, parameters: Parameters=None) -> RegisterThingResponse:
        pass

    def reject_certificate_transfer(self, certificateId: str, rejectReason: str=None):
        pass

    def remove_thing_from_billing_group(self, billingGroupName: str=None, billingGroupArn: str=None, thingName: str=None, thingArn: str=None) -> RemoveThingFromBillingGroupResponse:
        pass

    def remove_thing_from_thing_group(self, thingGroupName: str=None, thingGroupArn: str=None, thingName: str=None, thingArn: str=None) -> RemoveThingFromThingGroupResponse:
        pass

    def replace_topic_rule(self, topicRulePayload: TopicRulePayload, ruleName: str):
        pass

    def search_index(self, queryString: str, indexName: str=None, nextToken: str=None, maxResults: int=None, queryVersion: str=None) -> SearchIndexResponse:
        pass

    def set_default_authorizer(self, authorizerName: str) -> SetDefaultAuthorizerResponse:
        pass

    def set_default_policy_version(self, policyVersionId: str, policyName: str):
        pass

    def set_logging_options(self, loggingOptionsPayload: LoggingOptionsPayload):
        pass

    def set_v2_logging_level(self, logLevel: str, logTarget: LogTarget):
        pass

    def set_v2_logging_options(self, roleArn: str=None, defaultLogLevel: str=None, disableAllLogs: DisableAllLogs=None):
        pass

    def start_on_demand_audit_task(self, targetCheckNames: List[AuditCheckName]) -> StartOnDemandAuditTaskResponse:
        pass

    def start_thing_registration_task(self, roleArn: str, inputFileKey: str, inputFileBucket: str, templateBody: str) -> StartThingRegistrationTaskResponse:
        pass

    def stop_thing_registration_task(self, taskId: str) -> StopThingRegistrationTaskResponse:
        pass

    def tag_resource(self, tags: List[Tag], resourceArn: str) -> TagResourceResponse:
        pass

    def test_authorization(self, authInfos: List[AuthInfo], principal: str=None, cognitoIdentityPoolId: str=None, clientId: str=None, policyNamesToAdd: List[PolicyName]=None, policyNamesToSkip: List[PolicyName]=None) -> TestAuthorizationResponse:
        pass

    def test_invoke_authorizer(self, tokenSignature: str, token: str, authorizerName: str) -> TestInvokeAuthorizerResponse:
        pass

    def transfer_certificate(self, targetAwsAccount: str, certificateId: str, transferMessage: str=None) -> TransferCertificateResponse:
        pass

    def untag_resource(self, tagKeys: List[TagKey], resourceArn: str) -> UntagResourceResponse:
        pass

    def update_account_audit_configuration(self, roleArn: str=None, auditNotificationTargetConfigurations: AuditNotificationTargetConfigurations=None, auditCheckConfigurations: AuditCheckConfigurations=None) -> UpdateAccountAuditConfigurationResponse:
        pass

    def update_authorizer(self, authorizerName: str, authorizerFunctionArn: str=None, tokenKeyName: str=None, tokenSigningPublicKeys: PublicKeyMap=None, status: str=None) -> UpdateAuthorizerResponse:
        pass

    def update_billing_group(self, billingGroupProperties: BillingGroupProperties, billingGroupName: str, expectedVersion: OptionalVersion=None) -> UpdateBillingGroupResponse:
        pass

    def update_ca_certificate(self, certificateId: str, newStatus: str=None, newAutoRegistrationStatus: str=None, registrationConfig: RegistrationConfig=None, removeAutoRegistration: RemoveAutoRegistration=None):
        pass

    def update_certificate(self, newStatus: str, certificateId: str):
        pass

    def update_dynamic_thing_group(self, thingGroupProperties: ThingGroupProperties, thingGroupName: str, expectedVersion: OptionalVersion=None, indexName: str=None, queryString: str=None, queryVersion: str=None) -> UpdateDynamicThingGroupResponse:
        pass

    def update_event_configurations(self, eventConfigurations: EventConfigurations=None) -> UpdateEventConfigurationsResponse:
        pass

    def update_indexing_configuration(self, thingIndexingConfiguration: ThingIndexingConfiguration=None, thingGroupIndexingConfiguration: ThingGroupIndexingConfiguration=None) -> UpdateIndexingConfigurationResponse:
        pass

    def update_job(self, jobId: str, description: str=None, presignedUrlConfig: PresignedUrlConfig=None, jobExecutionsRolloutConfig: JobExecutionsRolloutConfig=None, abortConfig: AbortConfig=None, timeoutConfig: TimeoutConfig=None):
        pass

    def update_role_alias(self, roleAlias: str, roleArn: str=None, credentialDurationSeconds: int=None) -> UpdateRoleAliasResponse:
        pass

    def update_scheduled_audit(self, scheduledAuditName: str, frequency: str=None, dayOfMonth: str=None, dayOfWeek: str=None, targetCheckNames: List[AuditCheckName]=None) -> UpdateScheduledAuditResponse:
        pass

    def update_security_profile(self, securityProfileName: str, securityProfileDescription: str=None, behaviors: List[Behavior]=None, alertTargets: AlertTargets=None, expectedVersion: OptionalVersion=None) -> UpdateSecurityProfileResponse:
        pass

    def update_stream(self, streamId: str, description: str=None, files: List[StreamFile]=None, roleArn: str=None) -> UpdateStreamResponse:
        pass

    def update_thing(self, thingName: str, thingTypeName: str=None, attributePayload: AttributePayload=None, expectedVersion: OptionalVersion=None, removeThingType: RemoveThingType=None) -> UpdateThingResponse:
        pass

    def update_thing_group(self, thingGroupProperties: ThingGroupProperties, thingGroupName: str, expectedVersion: OptionalVersion=None) -> UpdateThingGroupResponse:
        pass

    def update_thing_groups_for_thing(self, thingName: str=None, thingGroupsToAdd: List[ThingGroupName]=None, thingGroupsToRemove: List[ThingGroupName]=None, overrideDynamicGroups: OverrideDynamicGroups=None) -> UpdateThingGroupsForThingResponse:
        pass

    def validate_security_profile_behaviors(self, behaviors: List[Behavior]) -> ValidateSecurityProfileBehaviorsResponse:
        pass


class IoTDataPlane(BaseClient):
    class DeleteThingShadowRequest(Mapping):
        pass

    class DeleteThingShadowResponse(Mapping):
        pass

    class GetThingShadowRequest(Mapping):
        pass

    class GetThingShadowResponse(Mapping):
        pass

    class PublishRequest(Mapping):
        pass

    class Payload(object):
        pass

    class UpdateThingShadowRequest(Mapping):
        pass

    class UpdateThingShadowResponse(Mapping):
        pass

    class JsonDocument(object):
        pass

    def delete_thing_shadow(self, thingName: str) -> DeleteThingShadowResponse:
        pass

    def get_thing_shadow(self, thingName: str) -> GetThingShadowResponse:
        pass

    def publish(self, topic: str, qos: int=None, payload: Payload=None):
        pass

    def update_thing_shadow(self, payload: JsonDocument, thingName: str) -> UpdateThingShadowResponse:
        pass


class IoTJobsDataPlane(BaseClient):
    class DescribeJobExecutionRequest(Mapping):
        pass

    class DescribeJobExecutionResponse(Mapping):
        pass

    class IncludeJobDocument(object):
        pass

    class ExecutionNumber(object):
        pass

    class GetPendingJobExecutionsRequest(Mapping):
        pass

    class GetPendingJobExecutionsResponse(Mapping):
        pass

    class StartNextPendingJobExecutionRequest(Mapping):
        pass

    class StartNextPendingJobExecutionResponse(Mapping):
        pass

    class DetailsMap(object):
        pass

    class StepTimeoutInMinutes(object):
        pass

    class UpdateJobExecutionRequest(Mapping):
        pass

    class UpdateJobExecutionResponse(Mapping):
        pass

    class ExpectedVersion(object):
        pass

    class IncludeExecutionState(object):
        pass

    def describe_job_execution(self, thingName: str, jobId: str, includeJobDocument: IncludeJobDocument=None, executionNumber: ExecutionNumber=None) -> DescribeJobExecutionResponse:
        pass

    def get_pending_job_executions(self, thingName: str) -> GetPendingJobExecutionsResponse:
        pass

    def start_next_pending_job_execution(self, thingName: str, statusDetails: DetailsMap=None, stepTimeoutInMinutes: StepTimeoutInMinutes=None) -> StartNextPendingJobExecutionResponse:
        pass

    def update_job_execution(self, status: str, thingName: str, jobId: str, statusDetails: DetailsMap=None, stepTimeoutInMinutes: StepTimeoutInMinutes=None, expectedVersion: ExpectedVersion=None, includeJobExecutionState: IncludeExecutionState=None, includeJobDocument: IncludeJobDocument=None, executionNumber: ExecutionNumber=None) -> UpdateJobExecutionResponse:
        pass


class IoT1ClickDevicesService(BaseClient):
    class ClaimDevicesByClaimCodeRequest(Mapping):
        pass

    class ClaimDevicesByClaimCodeResponse(Mapping):
        pass

    class DescribeDeviceRequest(Mapping):
        pass

    class DescribeDeviceResponse(Mapping):
        pass

    class FinalizeDeviceClaimRequest(Mapping):
        pass

    class FinalizeDeviceClaimResponse(Mapping):
        pass

    class GetDeviceMethodsRequest(Mapping):
        pass

    class GetDeviceMethodsResponse(Mapping):
        pass

    class InitiateDeviceClaimRequest(Mapping):
        pass

    class InitiateDeviceClaimResponse(Mapping):
        pass

    class InvokeDeviceMethodRequest(Mapping):
        pass

    class InvokeDeviceMethodResponse(Mapping):
        pass

    class DeviceMethod(Mapping):
        pass

    class ListDeviceEventsRequest(Mapping):
        pass

    class ListDeviceEventsResponse(Mapping):
        pass

    class __timestampIso8601(object):
        pass

    class ListDevicesRequest(Mapping):
        pass

    class ListDevicesResponse(Mapping):
        pass

    class UnclaimDeviceRequest(Mapping):
        pass

    class UnclaimDeviceResponse(Mapping):
        pass

    class UpdateDeviceStateRequest(Mapping):
        pass

    class UpdateDeviceStateResponse(Mapping):
        pass

    class __boolean(object):
        pass

    def claim_devices_by_claim_code(self, ClaimCode: str) -> ClaimDevicesByClaimCodeResponse:
        pass

    def describe_device(self, DeviceId: str) -> DescribeDeviceResponse:
        pass

    def finalize_device_claim(self, DeviceId: str) -> FinalizeDeviceClaimResponse:
        pass

    def get_device_methods(self, DeviceId: str) -> GetDeviceMethodsResponse:
        pass

    def initiate_device_claim(self, DeviceId: str) -> InitiateDeviceClaimResponse:
        pass

    def invoke_device_method(self, DeviceId: str, DeviceMethod: DeviceMethod=None, DeviceMethodParameters: str=None) -> InvokeDeviceMethodResponse:
        pass

    def list_device_events(self, ToTimeStamp: __timestampIso8601, FromTimeStamp: __timestampIso8601, DeviceId: str, MaxResults: int=None, NextToken: str=None) -> ListDeviceEventsResponse:
        pass

    def list_devices(self, DeviceType: str=None, MaxResults: int=None, NextToken: str=None) -> ListDevicesResponse:
        pass

    def unclaim_device(self, DeviceId: str) -> UnclaimDeviceResponse:
        pass

    def update_device_state(self, DeviceId: str, Enabled: __boolean=None) -> UpdateDeviceStateResponse:
        pass


class IoT1ClickProjects(BaseClient):
    class AssociateDeviceWithPlacementRequest(Mapping):
        pass

    class AssociateDeviceWithPlacementResponse(Mapping):
        pass

    class CreatePlacementRequest(Mapping):
        pass

    class CreatePlacementResponse(Mapping):
        pass

    class PlacementAttributeMap(object):
        pass

    class CreateProjectRequest(Mapping):
        pass

    class CreateProjectResponse(Mapping):
        pass

    class PlacementTemplate(Mapping):
        pass

    class DeletePlacementRequest(Mapping):
        pass

    class DeletePlacementResponse(Mapping):
        pass

    class DeleteProjectRequest(Mapping):
        pass

    class DeleteProjectResponse(Mapping):
        pass

    class DescribePlacementRequest(Mapping):
        pass

    class DescribePlacementResponse(Mapping):
        pass

    class DescribeProjectRequest(Mapping):
        pass

    class DescribeProjectResponse(Mapping):
        pass

    class DisassociateDeviceFromPlacementRequest(Mapping):
        pass

    class DisassociateDeviceFromPlacementResponse(Mapping):
        pass

    class GetDevicesInPlacementRequest(Mapping):
        pass

    class GetDevicesInPlacementResponse(Mapping):
        pass

    class ListPlacementsRequest(Mapping):
        pass

    class ListPlacementsResponse(Mapping):
        pass

    class ListProjectsRequest(Mapping):
        pass

    class ListProjectsResponse(Mapping):
        pass

    class UpdatePlacementRequest(Mapping):
        pass

    class UpdatePlacementResponse(Mapping):
        pass

    class UpdateProjectRequest(Mapping):
        pass

    class UpdateProjectResponse(Mapping):
        pass

    def associate_device_with_placement(self, deviceTemplateName: str, deviceId: str, placementName: str, projectName: str) -> AssociateDeviceWithPlacementResponse:
        pass

    def create_placement(self, projectName: str, placementName: str, attributes: PlacementAttributeMap=None) -> CreatePlacementResponse:
        pass

    def create_project(self, projectName: str, description: str=None, placementTemplate: PlacementTemplate=None) -> CreateProjectResponse:
        pass

    def delete_placement(self, projectName: str, placementName: str) -> DeletePlacementResponse:
        pass

    def delete_project(self, projectName: str) -> DeleteProjectResponse:
        pass

    def describe_placement(self, projectName: str, placementName: str) -> DescribePlacementResponse:
        pass

    def describe_project(self, projectName: str) -> DescribeProjectResponse:
        pass

    def disassociate_device_from_placement(self, deviceTemplateName: str, placementName: str, projectName: str) -> DisassociateDeviceFromPlacementResponse:
        pass

    def get_devices_in_placement(self, placementName: str, projectName: str) -> GetDevicesInPlacementResponse:
        pass

    def list_placements(self, projectName: str, nextToken: str=None, maxResults: int=None) -> ListPlacementsResponse:
        pass

    def list_projects(self, nextToken: str=None, maxResults: int=None) -> ListProjectsResponse:
        pass

    def update_placement(self, projectName: str, placementName: str, attributes: PlacementAttributeMap=None) -> UpdatePlacementResponse:
        pass

    def update_project(self, projectName: str, description: str=None, placementTemplate: PlacementTemplate=None) -> UpdateProjectResponse:
        pass


class IoTAnalytics(BaseClient):
    class BatchPutMessageRequest(Mapping):
        pass

    class BatchPutMessageResponse(Mapping):
        pass

    class Message(Mapping):
        pass

    class CancelPipelineReprocessingRequest(Mapping):
        pass

    class CancelPipelineReprocessingResponse(Mapping):
        pass

    class CreateChannelRequest(Mapping):
        pass

    class CreateChannelResponse(Mapping):
        pass

    class RetentionPeriod(Mapping):
        pass

    class Tag(Mapping):
        pass

    class CreateDatasetRequest(Mapping):
        pass

    class CreateDatasetResponse(Mapping):
        pass

    class DatasetAction(Mapping):
        pass

    class DatasetTrigger(Mapping):
        pass

    class DatasetContentDeliveryRule(Mapping):
        pass

    class CreateDatasetContentRequest(Mapping):
        pass

    class CreateDatasetContentResponse(Mapping):
        pass

    class CreateDatastoreRequest(Mapping):
        pass

    class CreateDatastoreResponse(Mapping):
        pass

    class CreatePipelineRequest(Mapping):
        pass

    class CreatePipelineResponse(Mapping):
        pass

    class PipelineActivity(Mapping):
        pass

    class DeleteChannelRequest(Mapping):
        pass

    class DeleteDatasetRequest(Mapping):
        pass

    class DeleteDatasetContentRequest(Mapping):
        pass

    class DeleteDatastoreRequest(Mapping):
        pass

    class DeletePipelineRequest(Mapping):
        pass

    class DescribeChannelRequest(Mapping):
        pass

    class DescribeChannelResponse(Mapping):
        pass

    class IncludeStatisticsFlag(object):
        pass

    class DescribeDatasetRequest(Mapping):
        pass

    class DescribeDatasetResponse(Mapping):
        pass

    class DescribeDatastoreRequest(Mapping):
        pass

    class DescribeDatastoreResponse(Mapping):
        pass

    class DescribeLoggingOptionsRequest(Mapping):
        pass

    class DescribeLoggingOptionsResponse(Mapping):
        pass

    class DescribePipelineRequest(Mapping):
        pass

    class DescribePipelineResponse(Mapping):
        pass

    class GetDatasetContentRequest(Mapping):
        pass

    class GetDatasetContentResponse(Mapping):
        pass

    class ListChannelsRequest(Mapping):
        pass

    class ListChannelsResponse(Mapping):
        pass

    class ListDatasetContentsRequest(Mapping):
        pass

    class ListDatasetContentsResponse(Mapping):
        pass

    class Timestamp(object):
        pass

    class ListDatasetsRequest(Mapping):
        pass

    class ListDatasetsResponse(Mapping):
        pass

    class ListDatastoresRequest(Mapping):
        pass

    class ListDatastoresResponse(Mapping):
        pass

    class ListPipelinesRequest(Mapping):
        pass

    class ListPipelinesResponse(Mapping):
        pass

    class ListTagsForResourceRequest(Mapping):
        pass

    class ListTagsForResourceResponse(Mapping):
        pass

    class PutLoggingOptionsRequest(Mapping):
        pass

    class LoggingOptions(Mapping):
        pass

    class RunPipelineActivityRequest(Mapping):
        pass

    class RunPipelineActivityResponse(Mapping):
        pass

    class MessagePayload(object):
        pass

    class SampleChannelDataRequest(Mapping):
        pass

    class SampleChannelDataResponse(Mapping):
        pass

    class StartTime(object):
        pass

    class EndTime(object):
        pass

    class StartPipelineReprocessingRequest(Mapping):
        pass

    class StartPipelineReprocessingResponse(Mapping):
        pass

    class TagResourceRequest(Mapping):
        pass

    class TagResourceResponse(Mapping):
        pass

    class UntagResourceRequest(Mapping):
        pass

    class UntagResourceResponse(Mapping):
        pass

    class TagKey(object):
        pass

    class UpdateChannelRequest(Mapping):
        pass

    class UpdateDatasetRequest(Mapping):
        pass

    class UpdateDatastoreRequest(Mapping):
        pass

    class UpdatePipelineRequest(Mapping):
        pass

    def batch_put_message(self, messages: List[Message], channelName: str) -> BatchPutMessageResponse:
        pass

    def cancel_pipeline_reprocessing(self, reprocessingId: str, pipelineName: str) -> CancelPipelineReprocessingResponse:
        pass

    def create_channel(self, channelName: str, retentionPeriod: RetentionPeriod=None, tags: List[Tag]=None) -> CreateChannelResponse:
        pass

    def create_dataset(self, actions: List[DatasetAction], datasetName: str, triggers: List[DatasetTrigger]=None, contentDeliveryRules: List[DatasetContentDeliveryRule]=None, retentionPeriod: RetentionPeriod=None, tags: List[Tag]=None) -> CreateDatasetResponse:
        pass

    def create_dataset_content(self, datasetName: str) -> CreateDatasetContentResponse:
        pass

    def create_datastore(self, datastoreName: str, retentionPeriod: RetentionPeriod=None, tags: List[Tag]=None) -> CreateDatastoreResponse:
        pass

    def create_pipeline(self, pipelineActivities: List[PipelineActivity], pipelineName: str, tags: List[Tag]=None) -> CreatePipelineResponse:
        pass

    def delete_channel(self, channelName: str):
        pass

    def delete_dataset(self, datasetName: str):
        pass

    def delete_dataset_content(self, datasetName: str, versionId: str=None):
        pass

    def delete_datastore(self, datastoreName: str):
        pass

    def delete_pipeline(self, pipelineName: str):
        pass

    def describe_channel(self, channelName: str, includeStatistics: IncludeStatisticsFlag=None) -> DescribeChannelResponse:
        pass

    def describe_dataset(self, datasetName: str) -> DescribeDatasetResponse:
        pass

    def describe_datastore(self, datastoreName: str, includeStatistics: IncludeStatisticsFlag=None) -> DescribeDatastoreResponse:
        pass

    def describe_logging_options(self) -> DescribeLoggingOptionsResponse:
        pass

    def describe_pipeline(self, pipelineName: str) -> DescribePipelineResponse:
        pass

    def get_dataset_content(self, datasetName: str, versionId: str=None) -> GetDatasetContentResponse:
        pass

    def list_channels(self, nextToken: str=None, maxResults: int=None) -> ListChannelsResponse:
        pass

    def list_dataset_contents(self, datasetName: str, nextToken: str=None, maxResults: int=None, scheduledOnOrAfter: Timestamp=None, scheduledBefore: Timestamp=None) -> ListDatasetContentsResponse:
        pass

    def list_datasets(self, nextToken: str=None, maxResults: int=None) -> ListDatasetsResponse:
        pass

    def list_datastores(self, nextToken: str=None, maxResults: int=None) -> ListDatastoresResponse:
        pass

    def list_pipelines(self, nextToken: str=None, maxResults: int=None) -> ListPipelinesResponse:
        pass

    def list_tags_for_resource(self, resourceArn: str) -> ListTagsForResourceResponse:
        pass

    def put_logging_options(self, loggingOptions: LoggingOptions):
        pass

    def run_pipeline_activity(self, payloads: List[MessagePayload], pipelineActivity: PipelineActivity) -> RunPipelineActivityResponse:
        pass

    def sample_channel_data(self, channelName: str, maxMessages: int=None, startTime: StartTime=None, endTime: EndTime=None) -> SampleChannelDataResponse:
        pass

    def start_pipeline_reprocessing(self, pipelineName: str, startTime: StartTime=None, endTime: EndTime=None) -> StartPipelineReprocessingResponse:
        pass

    def tag_resource(self, tags: List[Tag], resourceArn: str) -> TagResourceResponse:
        pass

    def untag_resource(self, tagKeys: List[TagKey], resourceArn: str) -> UntagResourceResponse:
        pass

    def update_channel(self, channelName: str, retentionPeriod: RetentionPeriod=None):
        pass

    def update_dataset(self, actions: List[DatasetAction], datasetName: str, triggers: List[DatasetTrigger]=None, contentDeliveryRules: List[DatasetContentDeliveryRule]=None, retentionPeriod: RetentionPeriod=None):
        pass

    def update_datastore(self, datastoreName: str, retentionPeriod: RetentionPeriod=None):
        pass

    def update_pipeline(self, pipelineActivities: List[PipelineActivity], pipelineName: str):
        pass


class Kafka(BaseClient):
    class CreateClusterRequest(Mapping):
        pass

    class CreateClusterResponse(Mapping):
        pass

    class BrokerNodeGroupInfo(Mapping):
        pass

    class EncryptionInfo(Mapping):
        pass

    class DeleteClusterRequest(Mapping):
        pass

    class DeleteClusterResponse(Mapping):
        pass

    class DescribeClusterRequest(Mapping):
        pass

    class DescribeClusterResponse(Mapping):
        pass

    class GetBootstrapBrokersRequest(Mapping):
        pass

    class GetBootstrapBrokersResponse(Mapping):
        pass

    class ListClustersRequest(Mapping):
        pass

    class ListClustersResponse(Mapping):
        pass

    class ListNodesRequest(Mapping):
        pass

    class ListNodesResponse(Mapping):
        pass

    def create_cluster(self, NumberOfBrokerNodes: int, KafkaVersion: str, ClusterName: str, BrokerNodeGroupInfo: BrokerNodeGroupInfo, EncryptionInfo: EncryptionInfo=None, EnhancedMonitoring: str=None) -> CreateClusterResponse:
        pass

    def delete_cluster(self, ClusterArn: str, CurrentVersion: str=None) -> DeleteClusterResponse:
        pass

    def describe_cluster(self, ClusterArn: str) -> DescribeClusterResponse:
        pass

    def get_bootstrap_brokers(self, ClusterArn: str) -> GetBootstrapBrokersResponse:
        pass

    def list_clusters(self, ClusterNameFilter: str=None, MaxResults: int=None, NextToken: str=None) -> ListClustersResponse:
        pass

    def list_nodes(self, ClusterArn: str, MaxResults: int=None, NextToken: str=None) -> ListNodesResponse:
        pass


class Kinesis(BaseClient):
    class AddTagsToStreamInput(Mapping):
        pass

    class TagMap(object):
        pass

    class CreateStreamInput(Mapping):
        pass

    class DecreaseStreamRetentionPeriodInput(Mapping):
        pass

    class DeleteStreamInput(Mapping):
        pass

    class BooleanObject(object):
        pass

    class DeregisterStreamConsumerInput(Mapping):
        pass

    class DescribeLimitsInput(Mapping):
        pass

    class DescribeLimitsOutput(Mapping):
        pass

    class DescribeStreamInput(Mapping):
        pass

    class DescribeStreamOutput(Mapping):
        pass

    class DescribeStreamConsumerInput(Mapping):
        pass

    class DescribeStreamConsumerOutput(Mapping):
        pass

    class DescribeStreamSummaryInput(Mapping):
        pass

    class DescribeStreamSummaryOutput(Mapping):
        pass

    class DisableEnhancedMonitoringInput(Mapping):
        pass

    class EnhancedMonitoringOutput(Mapping):
        pass

    class MetricsName(object):
        pass

    class EnableEnhancedMonitoringInput(Mapping):
        pass

    class GetRecordsInput(Mapping):
        pass

    class GetRecordsOutput(Mapping):
        pass

    class GetShardIteratorInput(Mapping):
        pass

    class GetShardIteratorOutput(Mapping):
        pass

    class Timestamp(object):
        pass

    class IncreaseStreamRetentionPeriodInput(Mapping):
        pass

    class ListShardsInput(Mapping):
        pass

    class ListShardsOutput(Mapping):
        pass

    class ListStreamConsumersInput(Mapping):
        pass

    class ListStreamConsumersOutput(Mapping):
        pass

    class ListStreamsInput(Mapping):
        pass

    class ListStreamsOutput(Mapping):
        pass

    class ListTagsForStreamInput(Mapping):
        pass

    class ListTagsForStreamOutput(Mapping):
        pass

    class MergeShardsInput(Mapping):
        pass

    class PutRecordInput(Mapping):
        pass

    class PutRecordOutput(Mapping):
        pass

    class Data(object):
        pass

    class PutRecordsInput(Mapping):
        pass

    class PutRecordsOutput(Mapping):
        pass

    class PutRecordsRequestEntry(Mapping):
        pass

    class RegisterStreamConsumerInput(Mapping):
        pass

    class RegisterStreamConsumerOutput(Mapping):
        pass

    class RemoveTagsFromStreamInput(Mapping):
        pass

    class TagKey(object):
        pass

    class SplitShardInput(Mapping):
        pass

    class StartStreamEncryptionInput(Mapping):
        pass

    class StopStreamEncryptionInput(Mapping):
        pass

    class SubscribeToShardInput(Mapping):
        pass

    class SubscribeToShardOutput(Mapping):
        pass

    class StartingPosition(Mapping):
        pass

    class UpdateShardCountInput(Mapping):
        pass

    class UpdateShardCountOutput(Mapping):
        pass

    def add_tags_to_stream(self, Tags: TagMap, StreamName: str):
        pass

    def create_stream(self, ShardCount: int, StreamName: str):
        pass

    def decrease_stream_retention_period(self, RetentionPeriodHours: int, StreamName: str):
        pass

    def delete_stream(self, StreamName: str, EnforceConsumerDeletion: BooleanObject=None):
        pass

    def deregister_stream_consumer(self, StreamARN: str=None, ConsumerName: str=None, ConsumerARN: str=None):
        pass

    def describe_limits(self) -> DescribeLimitsOutput:
        pass

    def describe_stream(self, StreamName: str, Limit: int=None, ExclusiveStartShardId: str=None) -> DescribeStreamOutput:
        pass

    def describe_stream_consumer(self, StreamARN: str=None, ConsumerName: str=None, ConsumerARN: str=None) -> DescribeStreamConsumerOutput:
        pass

    def describe_stream_summary(self, StreamName: str) -> DescribeStreamSummaryOutput:
        pass

    def disable_enhanced_monitoring(self, ShardLevelMetrics: List[MetricsName], StreamName: str) -> EnhancedMonitoringOutput:
        pass

    def enable_enhanced_monitoring(self, ShardLevelMetrics: List[MetricsName], StreamName: str) -> EnhancedMonitoringOutput:
        pass

    def get_records(self, ShardIterator: str, Limit: int=None) -> GetRecordsOutput:
        pass

    def get_shard_iterator(self, ShardIteratorType: str, ShardId: str, StreamName: str, StartingSequenceNumber: str=None, Timestamp: Timestamp=None) -> GetShardIteratorOutput:
        pass

    def increase_stream_retention_period(self, RetentionPeriodHours: int, StreamName: str):
        pass

    def list_shards(self, StreamName: str=None, NextToken: str=None, ExclusiveStartShardId: str=None, MaxResults: int=None, StreamCreationTimestamp: Timestamp=None) -> ListShardsOutput:
        pass

    def list_stream_consumers(self, StreamARN: str, NextToken: str=None, MaxResults: int=None, StreamCreationTimestamp: Timestamp=None) -> ListStreamConsumersOutput:
        pass

    def list_streams(self, Limit: int=None, ExclusiveStartStreamName: str=None) -> ListStreamsOutput:
        pass

    def list_tags_for_stream(self, StreamName: str, ExclusiveStartTagKey: str=None, Limit: int=None) -> ListTagsForStreamOutput:
        pass

    def merge_shards(self, AdjacentShardToMerge: str, ShardToMerge: str, StreamName: str):
        pass

    def put_record(self, PartitionKey: str, Data: Data, StreamName: str, ExplicitHashKey: str=None, SequenceNumberForOrdering: str=None) -> PutRecordOutput:
        pass

    def put_records(self, StreamName: str, Records: List[PutRecordsRequestEntry]) -> PutRecordsOutput:
        pass

    def register_stream_consumer(self, ConsumerName: str, StreamARN: str) -> RegisterStreamConsumerOutput:
        pass

    def remove_tags_from_stream(self, TagKeys: List[TagKey], StreamName: str):
        pass

    def split_shard(self, NewStartingHashKey: str, ShardToSplit: str, StreamName: str):
        pass

    def start_stream_encryption(self, KeyId: str, EncryptionType: str, StreamName: str):
        pass

    def stop_stream_encryption(self, KeyId: str, EncryptionType: str, StreamName: str):
        pass

    def subscribe_to_shard(self, StartingPosition: StartingPosition, ShardId: str, ConsumerARN: str) -> SubscribeToShardOutput:
        pass

    def update_shard_count(self, ScalingType: str, TargetShardCount: int, StreamName: str) -> UpdateShardCountOutput:
        pass


class KinesisVideoArchivedMedia(BaseClient):
    class GetHLSStreamingSessionURLInput(Mapping):
        pass

    class GetHLSStreamingSessionURLOutput(Mapping):
        pass

    class HLSFragmentSelector(Mapping):
        pass

    class PageLimit(object):
        pass

    class GetMediaForFragmentListInput(Mapping):
        pass

    class GetMediaForFragmentListOutput(Mapping):
        pass

    class FragmentNumberString(object):
        pass

    class ListFragmentsInput(Mapping):
        pass

    class ListFragmentsOutput(Mapping):
        pass

    class FragmentSelector(Mapping):
        pass

    def get_hls_streaming_session_url(self, StreamName: str=None, StreamARN: str=None, PlaybackMode: str=None, HLSFragmentSelector: HLSFragmentSelector=None, DiscontinuityMode: str=None, Expires: int=None, MaxMediaPlaylistFragmentResults: PageLimit=None) -> GetHLSStreamingSessionURLOutput:
        pass

    def get_media_for_fragment_list(self, Fragments: List[FragmentNumberString], StreamName: str) -> GetMediaForFragmentListOutput:
        pass

    def list_fragments(self, StreamName: str, MaxResults: PageLimit=None, NextToken: str=None, FragmentSelector: FragmentSelector=None) -> ListFragmentsOutput:
        pass


class KinesisVideoMedia(BaseClient):
    class GetMediaInput(Mapping):
        pass

    class GetMediaOutput(Mapping):
        pass

    class StartSelector(Mapping):
        pass

    def get_media(self, StartSelector: StartSelector, StreamName: str=None, StreamARN: str=None) -> GetMediaOutput:
        pass


class KinesisAnalytics(BaseClient):
    class AddApplicationCloudWatchLoggingOptionRequest(Mapping):
        pass

    class AddApplicationCloudWatchLoggingOptionResponse(Mapping):
        pass

    class ApplicationVersionId(object):
        pass

    class CloudWatchLoggingOption(Mapping):
        pass

    class AddApplicationInputRequest(Mapping):
        pass

    class AddApplicationInputResponse(Mapping):
        pass

    class Input(Mapping):
        pass

    class AddApplicationInputProcessingConfigurationRequest(Mapping):
        pass

    class AddApplicationInputProcessingConfigurationResponse(Mapping):
        pass

    class InputProcessingConfiguration(Mapping):
        pass

    class AddApplicationOutputRequest(Mapping):
        pass

    class AddApplicationOutputResponse(Mapping):
        pass

    class Output(Mapping):
        pass

    class AddApplicationReferenceDataSourceRequest(Mapping):
        pass

    class AddApplicationReferenceDataSourceResponse(Mapping):
        pass

    class ReferenceDataSource(Mapping):
        pass

    class CreateApplicationRequest(Mapping):
        pass

    class CreateApplicationResponse(Mapping):
        pass

    class DeleteApplicationRequest(Mapping):
        pass

    class DeleteApplicationResponse(Mapping):
        pass

    class Timestamp(object):
        pass

    class DeleteApplicationCloudWatchLoggingOptionRequest(Mapping):
        pass

    class DeleteApplicationCloudWatchLoggingOptionResponse(Mapping):
        pass

    class DeleteApplicationInputProcessingConfigurationRequest(Mapping):
        pass

    class DeleteApplicationInputProcessingConfigurationResponse(Mapping):
        pass

    class DeleteApplicationOutputRequest(Mapping):
        pass

    class DeleteApplicationOutputResponse(Mapping):
        pass

    class DeleteApplicationReferenceDataSourceRequest(Mapping):
        pass

    class DeleteApplicationReferenceDataSourceResponse(Mapping):
        pass

    class DescribeApplicationRequest(Mapping):
        pass

    class DescribeApplicationResponse(Mapping):
        pass

    class DiscoverInputSchemaRequest(Mapping):
        pass

    class DiscoverInputSchemaResponse(Mapping):
        pass

    class InputStartingPositionConfiguration(Mapping):
        pass

    class S3Configuration(Mapping):
        pass

    class ListApplicationsRequest(Mapping):
        pass

    class ListApplicationsResponse(Mapping):
        pass

    class StartApplicationRequest(Mapping):
        pass

    class StartApplicationResponse(Mapping):
        pass

    class InputConfiguration(Mapping):
        pass

    class StopApplicationRequest(Mapping):
        pass

    class StopApplicationResponse(Mapping):
        pass

    class UpdateApplicationRequest(Mapping):
        pass

    class UpdateApplicationResponse(Mapping):
        pass

    class ApplicationUpdate(Mapping):
        pass

    def add_application_cloud_watch_logging_option(self, CloudWatchLoggingOption: CloudWatchLoggingOption, CurrentApplicationVersionId: ApplicationVersionId, ApplicationName: str) -> AddApplicationCloudWatchLoggingOptionResponse:
        pass

    def add_application_input(self, Input: Input, CurrentApplicationVersionId: ApplicationVersionId, ApplicationName: str) -> AddApplicationInputResponse:
        pass

    def add_application_input_processing_configuration(self, InputProcessingConfiguration: InputProcessingConfiguration, InputId: str, CurrentApplicationVersionId: ApplicationVersionId, ApplicationName: str) -> AddApplicationInputProcessingConfigurationResponse:
        pass

    def add_application_output(self, Output: Output, CurrentApplicationVersionId: ApplicationVersionId, ApplicationName: str) -> AddApplicationOutputResponse:
        pass

    def add_application_reference_data_source(self, ReferenceDataSource: ReferenceDataSource, CurrentApplicationVersionId: ApplicationVersionId, ApplicationName: str) -> AddApplicationReferenceDataSourceResponse:
        pass

    def create_application(self, ApplicationName: str, ApplicationDescription: str=None, Inputs: List[Input]=None, Outputs: List[Output]=None, CloudWatchLoggingOptions: List[CloudWatchLoggingOption]=None, ApplicationCode: str=None) -> CreateApplicationResponse:
        pass

    def delete_application(self, CreateTimestamp: Timestamp, ApplicationName: str) -> DeleteApplicationResponse:
        pass

    def delete_application_cloud_watch_logging_option(self, CloudWatchLoggingOptionId: str, CurrentApplicationVersionId: ApplicationVersionId, ApplicationName: str) -> DeleteApplicationCloudWatchLoggingOptionResponse:
        pass

    def delete_application_input_processing_configuration(self, InputId: str, CurrentApplicationVersionId: ApplicationVersionId, ApplicationName: str) -> DeleteApplicationInputProcessingConfigurationResponse:
        pass

    def delete_application_output(self, OutputId: str, CurrentApplicationVersionId: ApplicationVersionId, ApplicationName: str) -> DeleteApplicationOutputResponse:
        pass

    def delete_application_reference_data_source(self, ReferenceId: str, CurrentApplicationVersionId: ApplicationVersionId, ApplicationName: str) -> DeleteApplicationReferenceDataSourceResponse:
        pass

    def describe_application(self, ApplicationName: str) -> DescribeApplicationResponse:
        pass

    def discover_input_schema(self, ResourceARN: str=None, RoleARN: str=None, InputStartingPositionConfiguration: InputStartingPositionConfiguration=None, S3Configuration: S3Configuration=None, InputProcessingConfiguration: InputProcessingConfiguration=None) -> DiscoverInputSchemaResponse:
        pass

    def list_applications(self, Limit: int=None, ExclusiveStartApplicationName: str=None) -> ListApplicationsResponse:
        pass

    def start_application(self, InputConfigurations: List[InputConfiguration], ApplicationName: str) -> StartApplicationResponse:
        pass

    def stop_application(self, ApplicationName: str) -> StopApplicationResponse:
        pass

    def update_application(self, ApplicationUpdate: ApplicationUpdate, CurrentApplicationVersionId: ApplicationVersionId, ApplicationName: str) -> UpdateApplicationResponse:
        pass


class KinesisAnalyticsV2(BaseClient):
    class AddApplicationCloudWatchLoggingOptionRequest(Mapping):
        pass

    class AddApplicationCloudWatchLoggingOptionResponse(Mapping):
        pass

    class ApplicationVersionId(object):
        pass

    class CloudWatchLoggingOption(Mapping):
        pass

    class AddApplicationInputRequest(Mapping):
        pass

    class AddApplicationInputResponse(Mapping):
        pass

    class Input(Mapping):
        pass

    class AddApplicationInputProcessingConfigurationRequest(Mapping):
        pass

    class AddApplicationInputProcessingConfigurationResponse(Mapping):
        pass

    class InputProcessingConfiguration(Mapping):
        pass

    class AddApplicationOutputRequest(Mapping):
        pass

    class AddApplicationOutputResponse(Mapping):
        pass

    class Output(Mapping):
        pass

    class AddApplicationReferenceDataSourceRequest(Mapping):
        pass

    class AddApplicationReferenceDataSourceResponse(Mapping):
        pass

    class ReferenceDataSource(Mapping):
        pass

    class CreateApplicationRequest(Mapping):
        pass

    class CreateApplicationResponse(Mapping):
        pass

    class ApplicationConfiguration(Mapping):
        pass

    class CreateApplicationSnapshotRequest(Mapping):
        pass

    class CreateApplicationSnapshotResponse(Mapping):
        pass

    class DeleteApplicationRequest(Mapping):
        pass

    class DeleteApplicationResponse(Mapping):
        pass

    class Timestamp(object):
        pass

    class DeleteApplicationCloudWatchLoggingOptionRequest(Mapping):
        pass

    class DeleteApplicationCloudWatchLoggingOptionResponse(Mapping):
        pass

    class DeleteApplicationInputProcessingConfigurationRequest(Mapping):
        pass

    class DeleteApplicationInputProcessingConfigurationResponse(Mapping):
        pass

    class DeleteApplicationOutputRequest(Mapping):
        pass

    class DeleteApplicationOutputResponse(Mapping):
        pass

    class DeleteApplicationReferenceDataSourceRequest(Mapping):
        pass

    class DeleteApplicationReferenceDataSourceResponse(Mapping):
        pass

    class DeleteApplicationSnapshotRequest(Mapping):
        pass

    class DeleteApplicationSnapshotResponse(Mapping):
        pass

    class DescribeApplicationRequest(Mapping):
        pass

    class DescribeApplicationResponse(Mapping):
        pass

    class BooleanObject(object):
        pass

    class DescribeApplicationSnapshotRequest(Mapping):
        pass

    class DescribeApplicationSnapshotResponse(Mapping):
        pass

    class DiscoverInputSchemaRequest(Mapping):
        pass

    class DiscoverInputSchemaResponse(Mapping):
        pass

    class InputStartingPositionConfiguration(Mapping):
        pass

    class S3Configuration(Mapping):
        pass

    class ListApplicationSnapshotsRequest(Mapping):
        pass

    class ListApplicationSnapshotsResponse(Mapping):
        pass

    class ListApplicationsRequest(Mapping):
        pass

    class ListApplicationsResponse(Mapping):
        pass

    class StartApplicationRequest(Mapping):
        pass

    class StartApplicationResponse(Mapping):
        pass

    class RunConfiguration(Mapping):
        pass

    class StopApplicationRequest(Mapping):
        pass

    class StopApplicationResponse(Mapping):
        pass

    class UpdateApplicationRequest(Mapping):
        pass

    class UpdateApplicationResponse(Mapping):
        pass

    class ApplicationConfigurationUpdate(Mapping):
        pass

    class RunConfigurationUpdate(Mapping):
        pass

    class CloudWatchLoggingOptionUpdate(Mapping):
        pass

    def add_application_cloud_watch_logging_option(self, CloudWatchLoggingOption: CloudWatchLoggingOption, CurrentApplicationVersionId: ApplicationVersionId, ApplicationName: str) -> AddApplicationCloudWatchLoggingOptionResponse:
        pass

    def add_application_input(self, Input: Input, CurrentApplicationVersionId: ApplicationVersionId, ApplicationName: str) -> AddApplicationInputResponse:
        pass

    def add_application_input_processing_configuration(self, InputProcessingConfiguration: InputProcessingConfiguration, InputId: str, CurrentApplicationVersionId: ApplicationVersionId, ApplicationName: str) -> AddApplicationInputProcessingConfigurationResponse:
        pass

    def add_application_output(self, Output: Output, CurrentApplicationVersionId: ApplicationVersionId, ApplicationName: str) -> AddApplicationOutputResponse:
        pass

    def add_application_reference_data_source(self, ReferenceDataSource: ReferenceDataSource, CurrentApplicationVersionId: ApplicationVersionId, ApplicationName: str) -> AddApplicationReferenceDataSourceResponse:
        pass

    def create_application(self, ServiceExecutionRole: str, RuntimeEnvironment: str, ApplicationName: str, ApplicationDescription: str=None, ApplicationConfiguration: ApplicationConfiguration=None, CloudWatchLoggingOptions: List[CloudWatchLoggingOption]=None) -> CreateApplicationResponse:
        pass

    def create_application_snapshot(self, SnapshotName: str, ApplicationName: str) -> CreateApplicationSnapshotResponse:
        pass

    def delete_application(self, CreateTimestamp: Timestamp, ApplicationName: str) -> DeleteApplicationResponse:
        pass

    def delete_application_cloud_watch_logging_option(self, CloudWatchLoggingOptionId: str, CurrentApplicationVersionId: ApplicationVersionId, ApplicationName: str) -> DeleteApplicationCloudWatchLoggingOptionResponse:
        pass

    def delete_application_input_processing_configuration(self, InputId: str, CurrentApplicationVersionId: ApplicationVersionId, ApplicationName: str) -> DeleteApplicationInputProcessingConfigurationResponse:
        pass

    def delete_application_output(self, OutputId: str, CurrentApplicationVersionId: ApplicationVersionId, ApplicationName: str) -> DeleteApplicationOutputResponse:
        pass

    def delete_application_reference_data_source(self, ReferenceId: str, CurrentApplicationVersionId: ApplicationVersionId, ApplicationName: str) -> DeleteApplicationReferenceDataSourceResponse:
        pass

    def delete_application_snapshot(self, SnapshotCreationTimestamp: Timestamp, SnapshotName: str, ApplicationName: str) -> DeleteApplicationSnapshotResponse:
        pass

    def describe_application(self, ApplicationName: str, IncludeAdditionalDetails: BooleanObject=None) -> DescribeApplicationResponse:
        pass

    def describe_application_snapshot(self, SnapshotName: str, ApplicationName: str) -> DescribeApplicationSnapshotResponse:
        pass

    def discover_input_schema(self, ServiceExecutionRole: str, ResourceARN: str=None, InputStartingPositionConfiguration: InputStartingPositionConfiguration=None, S3Configuration: S3Configuration=None, InputProcessingConfiguration: InputProcessingConfiguration=None) -> DiscoverInputSchemaResponse:
        pass

    def list_application_snapshots(self, ApplicationName: str, Limit: int=None, NextToken: str=None) -> ListApplicationSnapshotsResponse:
        pass

    def list_applications(self, Limit: int=None, NextToken: str=None) -> ListApplicationsResponse:
        pass

    def start_application(self, RunConfiguration: RunConfiguration, ApplicationName: str) -> StartApplicationResponse:
        pass

    def stop_application(self, ApplicationName: str) -> StopApplicationResponse:
        pass

    def update_application(self, CurrentApplicationVersionId: ApplicationVersionId, ApplicationName: str, ApplicationConfigurationUpdate: ApplicationConfigurationUpdate=None, ServiceExecutionRoleUpdate: str=None, RunConfigurationUpdate: RunConfigurationUpdate=None, CloudWatchLoggingOptionUpdates: List[CloudWatchLoggingOptionUpdate]=None) -> UpdateApplicationResponse:
        pass


class KinesisVideo(BaseClient):
    class CreateStreamInput(Mapping):
        pass

    class CreateStreamOutput(Mapping):
        pass

    class DeleteStreamInput(Mapping):
        pass

    class DeleteStreamOutput(Mapping):
        pass

    class DescribeStreamInput(Mapping):
        pass

    class DescribeStreamOutput(Mapping):
        pass

    class GetDataEndpointInput(Mapping):
        pass

    class GetDataEndpointOutput(Mapping):
        pass

    class ListStreamsInput(Mapping):
        pass

    class ListStreamsOutput(Mapping):
        pass

    class StreamNameCondition(Mapping):
        pass

    class ListTagsForStreamInput(Mapping):
        pass

    class ListTagsForStreamOutput(Mapping):
        pass

    class TagStreamInput(Mapping):
        pass

    class TagStreamOutput(Mapping):
        pass

    class ResourceTags(object):
        pass

    class UntagStreamInput(Mapping):
        pass

    class UntagStreamOutput(Mapping):
        pass

    class TagKey(object):
        pass

    class UpdateDataRetentionInput(Mapping):
        pass

    class UpdateDataRetentionOutput(Mapping):
        pass

    class UpdateStreamInput(Mapping):
        pass

    class UpdateStreamOutput(Mapping):
        pass

    def create_stream(self, StreamName: str, DeviceName: str=None, MediaType: str=None, KmsKeyId: str=None, DataRetentionInHours: int=None) -> CreateStreamOutput:
        pass

    def delete_stream(self, StreamARN: str, CurrentVersion: str=None) -> DeleteStreamOutput:
        pass

    def describe_stream(self, StreamName: str=None, StreamARN: str=None) -> DescribeStreamOutput:
        pass

    def get_data_endpoint(self, APIName: str, StreamName: str=None, StreamARN: str=None) -> GetDataEndpointOutput:
        pass

    def list_streams(self, MaxResults: int=None, NextToken: str=None, StreamNameCondition: StreamNameCondition=None) -> ListStreamsOutput:
        pass

    def list_tags_for_stream(self, NextToken: str=None, StreamARN: str=None, StreamName: str=None) -> ListTagsForStreamOutput:
        pass

    def tag_stream(self, Tags: ResourceTags, StreamARN: str=None, StreamName: str=None) -> TagStreamOutput:
        pass

    def untag_stream(self, TagKeyList: List[TagKey], StreamARN: str=None, StreamName: str=None) -> UntagStreamOutput:
        pass

    def update_data_retention(self, DataRetentionChangeInHours: int, Operation: str, CurrentVersion: str, StreamName: str=None, StreamARN: str=None) -> UpdateDataRetentionOutput:
        pass

    def update_stream(self, CurrentVersion: str, StreamName: str=None, StreamARN: str=None, DeviceName: str=None, MediaType: str=None) -> UpdateStreamOutput:
        pass


class KMS(BaseClient):
    class CancelKeyDeletionRequest(Mapping):
        pass

    class CancelKeyDeletionResponse(Mapping):
        pass

    class ConnectCustomKeyStoreRequest(Mapping):
        pass

    class ConnectCustomKeyStoreResponse(Mapping):
        pass

    class CreateAliasRequest(Mapping):
        pass

    class CreateCustomKeyStoreRequest(Mapping):
        pass

    class CreateCustomKeyStoreResponse(Mapping):
        pass

    class CreateGrantRequest(Mapping):
        pass

    class CreateGrantResponse(Mapping):
        pass

    class GrantOperation(object):
        pass

    class GrantConstraints(Mapping):
        pass

    class GrantTokenType(object):
        pass

    class CreateKeyRequest(Mapping):
        pass

    class CreateKeyResponse(Mapping):
        pass

    class BooleanType(object):
        pass

    class Tag(Mapping):
        pass

    class DecryptRequest(Mapping):
        pass

    class DecryptResponse(Mapping):
        pass

    class CiphertextType(object):
        pass

    class EncryptionContextType(object):
        pass

    class DeleteAliasRequest(Mapping):
        pass

    class DeleteCustomKeyStoreRequest(Mapping):
        pass

    class DeleteCustomKeyStoreResponse(Mapping):
        pass

    class DeleteImportedKeyMaterialRequest(Mapping):
        pass

    class DescribeCustomKeyStoresRequest(Mapping):
        pass

    class DescribeCustomKeyStoresResponse(Mapping):
        pass

    class DescribeKeyRequest(Mapping):
        pass

    class DescribeKeyResponse(Mapping):
        pass

    class DisableKeyRequest(Mapping):
        pass

    class DisableKeyRotationRequest(Mapping):
        pass

    class DisconnectCustomKeyStoreRequest(Mapping):
        pass

    class DisconnectCustomKeyStoreResponse(Mapping):
        pass

    class EnableKeyRequest(Mapping):
        pass

    class EnableKeyRotationRequest(Mapping):
        pass

    class EncryptRequest(Mapping):
        pass

    class EncryptResponse(Mapping):
        pass

    class PlaintextType(object):
        pass

    class GenerateDataKeyRequest(Mapping):
        pass

    class GenerateDataKeyResponse(Mapping):
        pass

    class GenerateDataKeyWithoutPlaintextRequest(Mapping):
        pass

    class GenerateDataKeyWithoutPlaintextResponse(Mapping):
        pass

    class GenerateRandomRequest(Mapping):
        pass

    class GenerateRandomResponse(Mapping):
        pass

    class GetKeyPolicyRequest(Mapping):
        pass

    class GetKeyPolicyResponse(Mapping):
        pass

    class GetKeyRotationStatusRequest(Mapping):
        pass

    class GetKeyRotationStatusResponse(Mapping):
        pass

    class GetParametersForImportRequest(Mapping):
        pass

    class GetParametersForImportResponse(Mapping):
        pass

    class ImportKeyMaterialRequest(Mapping):
        pass

    class ImportKeyMaterialResponse(Mapping):
        pass

    class DateType(object):
        pass

    class ListAliasesRequest(Mapping):
        pass

    class ListAliasesResponse(Mapping):
        pass

    class ListGrantsRequest(Mapping):
        pass

    class ListGrantsResponse(Mapping):
        pass

    class ListKeyPoliciesRequest(Mapping):
        pass

    class ListKeyPoliciesResponse(Mapping):
        pass

    class ListKeysRequest(Mapping):
        pass

    class ListKeysResponse(Mapping):
        pass

    class ListResourceTagsRequest(Mapping):
        pass

    class ListResourceTagsResponse(Mapping):
        pass

    class ListRetirableGrantsRequest(Mapping):
        pass

    class PutKeyPolicyRequest(Mapping):
        pass

    class ReEncryptRequest(Mapping):
        pass

    class ReEncryptResponse(Mapping):
        pass

    class RetireGrantRequest(Mapping):
        pass

    class RevokeGrantRequest(Mapping):
        pass

    class ScheduleKeyDeletionRequest(Mapping):
        pass

    class ScheduleKeyDeletionResponse(Mapping):
        pass

    class TagResourceRequest(Mapping):
        pass

    class UntagResourceRequest(Mapping):
        pass

    class TagKeyType(object):
        pass

    class UpdateAliasRequest(Mapping):
        pass

    class UpdateCustomKeyStoreRequest(Mapping):
        pass

    class UpdateCustomKeyStoreResponse(Mapping):
        pass

    class UpdateKeyDescriptionRequest(Mapping):
        pass

    def cancel_key_deletion(self, KeyId: str) -> CancelKeyDeletionResponse:
        pass

    def connect_custom_key_store(self, CustomKeyStoreId: str) -> ConnectCustomKeyStoreResponse:
        pass

    def create_alias(self, TargetKeyId: str, AliasName: str):
        pass

    def create_custom_key_store(self, KeyStorePassword: str, TrustAnchorCertificate: str, CloudHsmClusterId: str, CustomKeyStoreName: str) -> CreateCustomKeyStoreResponse:
        pass

    def create_grant(self, Operations: List[GrantOperation], GranteePrincipal: str, KeyId: str, RetiringPrincipal: str=None, Constraints: GrantConstraints=None, GrantTokens: List[GrantTokenType]=None, Name: str=None) -> CreateGrantResponse:
        pass

    def create_key(self, Policy: str=None, Description: str=None, KeyUsage: str=None, Origin: str=None, CustomKeyStoreId: str=None, BypassPolicyLockoutSafetyCheck: BooleanType=None, Tags: List[Tag]=None) -> CreateKeyResponse:
        pass

    def decrypt(self, CiphertextBlob: CiphertextType, EncryptionContext: EncryptionContextType=None, GrantTokens: List[GrantTokenType]=None) -> DecryptResponse:
        pass

    def delete_alias(self, AliasName: str):
        pass

    def delete_custom_key_store(self, CustomKeyStoreId: str) -> DeleteCustomKeyStoreResponse:
        pass

    def delete_imported_key_material(self, KeyId: str):
        pass

    def describe_custom_key_stores(self, CustomKeyStoreId: str=None, CustomKeyStoreName: str=None, Limit: int=None, Marker: str=None) -> DescribeCustomKeyStoresResponse:
        pass

    def describe_key(self, KeyId: str, GrantTokens: List[GrantTokenType]=None) -> DescribeKeyResponse:
        pass

    def disable_key(self, KeyId: str):
        pass

    def disable_key_rotation(self, KeyId: str):
        pass

    def disconnect_custom_key_store(self, CustomKeyStoreId: str) -> DisconnectCustomKeyStoreResponse:
        pass

    def enable_key(self, KeyId: str):
        pass

    def enable_key_rotation(self, KeyId: str):
        pass

    def encrypt(self, Plaintext: PlaintextType, KeyId: str, EncryptionContext: EncryptionContextType=None, GrantTokens: List[GrantTokenType]=None) -> EncryptResponse:
        pass

    def generate_data_key(self, KeyId: str, EncryptionContext: EncryptionContextType=None, NumberOfBytes: int=None, KeySpec: str=None, GrantTokens: List[GrantTokenType]=None) -> GenerateDataKeyResponse:
        pass

    def generate_data_key_without_plaintext(self, KeyId: str, EncryptionContext: EncryptionContextType=None, KeySpec: str=None, NumberOfBytes: int=None, GrantTokens: List[GrantTokenType]=None) -> GenerateDataKeyWithoutPlaintextResponse:
        pass

    def generate_random(self, NumberOfBytes: int=None, CustomKeyStoreId: str=None) -> GenerateRandomResponse:
        pass

    def get_key_policy(self, PolicyName: str, KeyId: str) -> GetKeyPolicyResponse:
        pass

    def get_key_rotation_status(self, KeyId: str) -> GetKeyRotationStatusResponse:
        pass

    def get_parameters_for_import(self, WrappingKeySpec: str, WrappingAlgorithm: str, KeyId: str) -> GetParametersForImportResponse:
        pass

    def import_key_material(self, EncryptedKeyMaterial: CiphertextType, ImportToken: CiphertextType, KeyId: str, ValidTo: DateType=None, ExpirationModel: str=None) -> ImportKeyMaterialResponse:
        pass

    def list_aliases(self, KeyId: str=None, Limit: int=None, Marker: str=None) -> ListAliasesResponse:
        pass

    def list_grants(self, KeyId: str, Limit: int=None, Marker: str=None) -> ListGrantsResponse:
        pass

    def list_key_policies(self, KeyId: str, Limit: int=None, Marker: str=None) -> ListKeyPoliciesResponse:
        pass

    def list_keys(self, Limit: int=None, Marker: str=None) -> ListKeysResponse:
        pass

    def list_resource_tags(self, KeyId: str, Limit: int=None, Marker: str=None) -> ListResourceTagsResponse:
        pass

    def list_retirable_grants(self, RetiringPrincipal: str, Limit: int=None, Marker: str=None) -> ListGrantsResponse:
        pass

    def put_key_policy(self, Policy: str, PolicyName: str, KeyId: str, BypassPolicyLockoutSafetyCheck: BooleanType=None):
        pass

    def re_encrypt(self, DestinationKeyId: str, CiphertextBlob: CiphertextType, SourceEncryptionContext: EncryptionContextType=None, DestinationEncryptionContext: EncryptionContextType=None, GrantTokens: List[GrantTokenType]=None) -> ReEncryptResponse:
        pass

    def retire_grant(self, GrantToken: str=None, KeyId: str=None, GrantId: str=None):
        pass

    def revoke_grant(self, GrantId: str, KeyId: str):
        pass

    def schedule_key_deletion(self, KeyId: str, PendingWindowInDays: int=None) -> ScheduleKeyDeletionResponse:
        pass

    def tag_resource(self, Tags: List[Tag], KeyId: str):
        pass

    def untag_resource(self, TagKeys: List[TagKeyType], KeyId: str):
        pass

    def update_alias(self, TargetKeyId: str, AliasName: str):
        pass

    def update_custom_key_store(self, CustomKeyStoreId: str, NewCustomKeyStoreName: str=None, KeyStorePassword: str=None, CloudHsmClusterId: str=None) -> UpdateCustomKeyStoreResponse:
        pass

    def update_key_description(self, Description: str, KeyId: str):
        pass


class Lambda(BaseClient):
    class AddLayerVersionPermissionRequest(Mapping):
        pass

    class AddLayerVersionPermissionResponse(Mapping):
        pass

    class LayerVersionNumber(object):
        pass

    class AddPermissionRequest(Mapping):
        pass

    class AddPermissionResponse(Mapping):
        pass

    class CreateAliasRequest(Mapping):
        pass

    class AliasConfiguration(Mapping):
        pass

    class AliasRoutingConfiguration(Mapping):
        pass

    class CreateEventSourceMappingRequest(Mapping):
        pass

    class EventSourceMappingConfiguration(Mapping):
        pass

    class Enabled(object):
        pass

    class Date(object):
        pass

    class CreateFunctionRequest(Mapping):
        pass

    class FunctionConfiguration(Mapping):
        pass

    class FunctionCode(Mapping):
        pass

    class Boolean(object):
        pass

    class VpcConfig(Mapping):
        pass

    class DeadLetterConfig(Mapping):
        pass

    class Environment(Mapping):
        pass

    class TracingConfig(Mapping):
        pass

    class Tags(object):
        pass

    class LayerVersionArn(object):
        pass

    class DeleteAliasRequest(Mapping):
        pass

    class DeleteEventSourceMappingRequest(Mapping):
        pass

    class DeleteFunctionRequest(Mapping):
        pass

    class DeleteFunctionConcurrencyRequest(Mapping):
        pass

    class DeleteLayerVersionRequest(Mapping):
        pass

    class GetAccountSettingsRequest(Mapping):
        pass

    class GetAccountSettingsResponse(Mapping):
        pass

    class GetAliasRequest(Mapping):
        pass

    class GetEventSourceMappingRequest(Mapping):
        pass

    class GetFunctionRequest(Mapping):
        pass

    class GetFunctionResponse(Mapping):
        pass

    class GetFunctionConfigurationRequest(Mapping):
        pass

    class GetLayerVersionRequest(Mapping):
        pass

    class GetLayerVersionResponse(Mapping):
        pass

    class GetLayerVersionPolicyRequest(Mapping):
        pass

    class GetLayerVersionPolicyResponse(Mapping):
        pass

    class GetPolicyRequest(Mapping):
        pass

    class GetPolicyResponse(Mapping):
        pass

    class InvocationRequest(Mapping):
        pass

    class InvocationResponse(Mapping):
        pass

    class Blob(object):
        pass

    class InvokeAsyncRequest(Mapping):
        pass

    class InvokeAsyncResponse(Mapping):
        pass

    class BlobStream(object):
        pass

    class ListAliasesRequest(Mapping):
        pass

    class ListAliasesResponse(Mapping):
        pass

    class ListEventSourceMappingsRequest(Mapping):
        pass

    class ListEventSourceMappingsResponse(Mapping):
        pass

    class ListFunctionsRequest(Mapping):
        pass

    class ListFunctionsResponse(Mapping):
        pass

    class ListLayerVersionsRequest(Mapping):
        pass

    class ListLayerVersionsResponse(Mapping):
        pass

    class ListLayersRequest(Mapping):
        pass

    class ListLayersResponse(Mapping):
        pass

    class ListTagsRequest(Mapping):
        pass

    class ListTagsResponse(Mapping):
        pass

    class ListVersionsByFunctionRequest(Mapping):
        pass

    class ListVersionsByFunctionResponse(Mapping):
        pass

    class PublishLayerVersionRequest(Mapping):
        pass

    class PublishLayerVersionResponse(Mapping):
        pass

    class LayerVersionContentInput(Mapping):
        pass

    class Runtime(object):
        pass

    class PublishVersionRequest(Mapping):
        pass

    class PutFunctionConcurrencyRequest(Mapping):
        pass

    class Concurrency(Mapping):
        pass

    class RemoveLayerVersionPermissionRequest(Mapping):
        pass

    class RemovePermissionRequest(Mapping):
        pass

    class TagResourceRequest(Mapping):
        pass

    class UntagResourceRequest(Mapping):
        pass

    class TagKey(object):
        pass

    class UpdateAliasRequest(Mapping):
        pass

    class UpdateEventSourceMappingRequest(Mapping):
        pass

    class UpdateFunctionCodeRequest(Mapping):
        pass

    class UpdateFunctionConfigurationRequest(Mapping):
        pass

    def add_layer_version_permission(self, Principal: str, Action: str, StatementId: str, VersionNumber: LayerVersionNumber, LayerName: str, OrganizationId: str=None, RevisionId: str=None) -> AddLayerVersionPermissionResponse:
        pass

    def add_permission(self, Principal: str, Action: str, StatementId: str, FunctionName: str, SourceArn: str=None, SourceAccount: str=None, EventSourceToken: str=None, Qualifier: str=None, RevisionId: str=None) -> AddPermissionResponse:
        pass

    def create_alias(self, FunctionVersion: str, Name: str, FunctionName: str, Description: str=None, RoutingConfig: AliasRoutingConfiguration=None) -> AliasConfiguration:
        pass

    def create_event_source_mapping(self, FunctionName: str, EventSourceArn: str, Enabled: Enabled=None, BatchSize: int=None, StartingPosition: str=None, StartingPositionTimestamp: Date=None) -> EventSourceMappingConfiguration:
        pass

    def create_function(self, Code: FunctionCode, Handler: str, Role: str, Runtime: str, FunctionName: str, Description: str=None, Timeout: int=None, MemorySize: int=None, Publish: Boolean=None, VpcConfig: VpcConfig=None, DeadLetterConfig: DeadLetterConfig=None, Environment: Environment=None, KMSKeyArn: str=None, TracingConfig: TracingConfig=None, Tags: Tags=None, Layers: List[LayerVersionArn]=None) -> FunctionConfiguration:
        pass

    def delete_alias(self, Name: str, FunctionName: str):
        pass

    def delete_event_source_mapping(self, UUID: str) -> EventSourceMappingConfiguration:
        pass

    def delete_function(self, FunctionName: str, Qualifier: str=None):
        pass

    def delete_function_concurrency(self, FunctionName: str):
        pass

    def delete_layer_version(self, VersionNumber: LayerVersionNumber, LayerName: str):
        pass

    def get_account_settings(self) -> GetAccountSettingsResponse:
        pass

    def get_alias(self, Name: str, FunctionName: str) -> AliasConfiguration:
        pass

    def get_event_source_mapping(self, UUID: str) -> EventSourceMappingConfiguration:
        pass

    def get_function(self, FunctionName: str, Qualifier: str=None) -> GetFunctionResponse:
        pass

    def get_function_configuration(self, FunctionName: str, Qualifier: str=None) -> FunctionConfiguration:
        pass

    def get_layer_version(self, VersionNumber: LayerVersionNumber, LayerName: str) -> GetLayerVersionResponse:
        pass

    def get_layer_version_policy(self, VersionNumber: LayerVersionNumber, LayerName: str) -> GetLayerVersionPolicyResponse:
        pass

    def get_policy(self, FunctionName: str, Qualifier: str=None) -> GetPolicyResponse:
        pass

    def invoke(self, FunctionName: str, InvocationType: str=None, LogType: str=None, ClientContext: str=None, Payload: Blob=None, Qualifier: str=None) -> InvocationResponse:
        pass

    def invoke_async(self, InvokeArgs: BlobStream, FunctionName: str) -> InvokeAsyncResponse:
        pass

    def list_aliases(self, FunctionName: str, FunctionVersion: str=None, Marker: str=None, MaxItems: int=None) -> ListAliasesResponse:
        pass

    def list_event_source_mappings(self, EventSourceArn: str=None, FunctionName: str=None, Marker: str=None, MaxItems: int=None) -> ListEventSourceMappingsResponse:
        pass

    def list_functions(self, MasterRegion: str=None, FunctionVersion: str=None, Marker: str=None, MaxItems: int=None) -> ListFunctionsResponse:
        pass

    def list_layer_versions(self, LayerName: str, CompatibleRuntime: str=None, Marker: str=None, MaxItems: int=None) -> ListLayerVersionsResponse:
        pass

    def list_layers(self, CompatibleRuntime: str=None, Marker: str=None, MaxItems: int=None) -> ListLayersResponse:
        pass

    def list_tags(self, Resource: str) -> ListTagsResponse:
        pass

    def list_versions_by_function(self, FunctionName: str, Marker: str=None, MaxItems: int=None) -> ListVersionsByFunctionResponse:
        pass

    def publish_layer_version(self, Content: LayerVersionContentInput, LayerName: str, Description: str=None, CompatibleRuntimes: List[Runtime]=None, LicenseInfo: str=None) -> PublishLayerVersionResponse:
        pass

    def publish_version(self, FunctionName: str, CodeSha256: str=None, Description: str=None, RevisionId: str=None) -> FunctionConfiguration:
        pass

    def put_function_concurrency(self, ReservedConcurrentExecutions: int, FunctionName: str) -> Concurrency:
        pass

    def remove_layer_version_permission(self, StatementId: str, VersionNumber: LayerVersionNumber, LayerName: str, RevisionId: str=None):
        pass

    def remove_permission(self, StatementId: str, FunctionName: str, Qualifier: str=None, RevisionId: str=None):
        pass

    def tag_resource(self, Tags: Tags, Resource: str):
        pass

    def untag_resource(self, TagKeys: List[TagKey], Resource: str):
        pass

    def update_alias(self, Name: str, FunctionName: str, FunctionVersion: str=None, Description: str=None, RoutingConfig: AliasRoutingConfiguration=None, RevisionId: str=None) -> AliasConfiguration:
        pass

    def update_event_source_mapping(self, UUID: str, FunctionName: str=None, Enabled: Enabled=None, BatchSize: int=None) -> EventSourceMappingConfiguration:
        pass

    def update_function_code(self, FunctionName: str, ZipFile: Blob=None, S3Bucket: str=None, S3Key: str=None, S3ObjectVersion: str=None, Publish: Boolean=None, DryRun: Boolean=None, RevisionId: str=None) -> FunctionConfiguration:
        pass

    def update_function_configuration(self, FunctionName: str, Role: str=None, Handler: str=None, Description: str=None, Timeout: int=None, MemorySize: int=None, VpcConfig: VpcConfig=None, Environment: Environment=None, Runtime: str=None, DeadLetterConfig: DeadLetterConfig=None, KMSKeyArn: str=None, TracingConfig: TracingConfig=None, RevisionId: str=None, Layers: List[LayerVersionArn]=None) -> FunctionConfiguration:
        pass


class LexModelBuildingService(BaseClient):
    class CreateBotVersionRequest(Mapping):
        pass

    class CreateBotVersionResponse(Mapping):
        pass

    class CreateIntentVersionRequest(Mapping):
        pass

    class CreateIntentVersionResponse(Mapping):
        pass

    class CreateSlotTypeVersionRequest(Mapping):
        pass

    class CreateSlotTypeVersionResponse(Mapping):
        pass

    class DeleteBotRequest(Mapping):
        pass

    class DeleteBotAliasRequest(Mapping):
        pass

    class DeleteBotChannelAssociationRequest(Mapping):
        pass

    class DeleteBotVersionRequest(Mapping):
        pass

    class DeleteIntentRequest(Mapping):
        pass

    class DeleteIntentVersionRequest(Mapping):
        pass

    class DeleteSlotTypeRequest(Mapping):
        pass

    class DeleteSlotTypeVersionRequest(Mapping):
        pass

    class DeleteUtterancesRequest(Mapping):
        pass

    class GetBotRequest(Mapping):
        pass

    class GetBotResponse(Mapping):
        pass

    class GetBotAliasRequest(Mapping):
        pass

    class GetBotAliasResponse(Mapping):
        pass

    class GetBotAliasesRequest(Mapping):
        pass

    class GetBotAliasesResponse(Mapping):
        pass

    class GetBotChannelAssociationRequest(Mapping):
        pass

    class GetBotChannelAssociationResponse(Mapping):
        pass

    class GetBotChannelAssociationsRequest(Mapping):
        pass

    class GetBotChannelAssociationsResponse(Mapping):
        pass

    class GetBotVersionsRequest(Mapping):
        pass

    class GetBotVersionsResponse(Mapping):
        pass

    class GetBotsRequest(Mapping):
        pass

    class GetBotsResponse(Mapping):
        pass

    class GetBuiltinIntentRequest(Mapping):
        pass

    class GetBuiltinIntentResponse(Mapping):
        pass

    class GetBuiltinIntentsRequest(Mapping):
        pass

    class GetBuiltinIntentsResponse(Mapping):
        pass

    class GetBuiltinSlotTypesRequest(Mapping):
        pass

    class GetBuiltinSlotTypesResponse(Mapping):
        pass

    class GetExportRequest(Mapping):
        pass

    class GetExportResponse(Mapping):
        pass

    class GetImportRequest(Mapping):
        pass

    class GetImportResponse(Mapping):
        pass

    class GetIntentRequest(Mapping):
        pass

    class GetIntentResponse(Mapping):
        pass

    class GetIntentVersionsRequest(Mapping):
        pass

    class GetIntentVersionsResponse(Mapping):
        pass

    class GetIntentsRequest(Mapping):
        pass

    class GetIntentsResponse(Mapping):
        pass

    class GetSlotTypeRequest(Mapping):
        pass

    class GetSlotTypeResponse(Mapping):
        pass

    class GetSlotTypeVersionsRequest(Mapping):
        pass

    class GetSlotTypeVersionsResponse(Mapping):
        pass

    class GetSlotTypesRequest(Mapping):
        pass

    class GetSlotTypesResponse(Mapping):
        pass

    class GetUtterancesViewRequest(Mapping):
        pass

    class GetUtterancesViewResponse(Mapping):
        pass

    class Version(object):
        pass

    class PutBotRequest(Mapping):
        pass

    class PutBotResponse(Mapping):
        pass

    class Intent(Mapping):
        pass

    class Prompt(Mapping):
        pass

    class Statement(Mapping):
        pass

    class Boolean(object):
        pass

    class PutBotAliasRequest(Mapping):
        pass

    class PutBotAliasResponse(Mapping):
        pass

    class PutIntentRequest(Mapping):
        pass

    class PutIntentResponse(Mapping):
        pass

    class Slot(Mapping):
        pass

    class Utterance(object):
        pass

    class FollowUpPrompt(Mapping):
        pass

    class CodeHook(Mapping):
        pass

    class FulfillmentActivity(Mapping):
        pass

    class PutSlotTypeRequest(Mapping):
        pass

    class PutSlotTypeResponse(Mapping):
        pass

    class EnumerationValue(Mapping):
        pass

    class StartImportRequest(Mapping):
        pass

    class StartImportResponse(Mapping):
        pass

    class Blob(object):
        pass

    def create_bot_version(self, name: str, checksum: str=None) -> CreateBotVersionResponse:
        pass

    def create_intent_version(self, name: str, checksum: str=None) -> CreateIntentVersionResponse:
        pass

    def create_slot_type_version(self, name: str, checksum: str=None) -> CreateSlotTypeVersionResponse:
        pass

    def delete_bot(self, name: str):
        pass

    def delete_bot_alias(self, botName: str, name: str):
        pass

    def delete_bot_channel_association(self, botAlias: str, botName: str, name: str):
        pass

    def delete_bot_version(self, version: str, name: str):
        pass

    def delete_intent(self, name: str):
        pass

    def delete_intent_version(self, version: str, name: str):
        pass

    def delete_slot_type(self, name: str):
        pass

    def delete_slot_type_version(self, version: str, name: str):
        pass

    def delete_utterances(self, userId: str, botName: str):
        pass

    def get_bot(self, versionOrAlias: str, name: str) -> GetBotResponse:
        pass

    def get_bot_alias(self, botName: str, name: str) -> GetBotAliasResponse:
        pass

    def get_bot_aliases(self, botName: str, nextToken: str=None, maxResults: int=None, nameContains: str=None) -> GetBotAliasesResponse:
        pass

    def get_bot_channel_association(self, botAlias: str, botName: str, name: str) -> GetBotChannelAssociationResponse:
        pass

    def get_bot_channel_associations(self, botAlias: str, botName: str, nextToken: str=None, maxResults: int=None, nameContains: str=None) -> GetBotChannelAssociationsResponse:
        pass

    def get_bot_versions(self, name: str, nextToken: str=None, maxResults: int=None) -> GetBotVersionsResponse:
        pass

    def get_bots(self, nextToken: str=None, maxResults: int=None, nameContains: str=None) -> GetBotsResponse:
        pass

    def get_builtin_intent(self, signature: str) -> GetBuiltinIntentResponse:
        pass

    def get_builtin_intents(self, locale: str=None, signatureContains: str=None, nextToken: str=None, maxResults: int=None) -> GetBuiltinIntentsResponse:
        pass

    def get_builtin_slot_types(self, locale: str=None, signatureContains: str=None, nextToken: str=None, maxResults: int=None) -> GetBuiltinSlotTypesResponse:
        pass

    def get_export(self, exportType: str, resourceType: str, version: str, name: str) -> GetExportResponse:
        pass

    def get_import(self, importId: str) -> GetImportResponse:
        pass

    def get_intent(self, version: str, name: str) -> GetIntentResponse:
        pass

    def get_intent_versions(self, name: str, nextToken: str=None, maxResults: int=None) -> GetIntentVersionsResponse:
        pass

    def get_intents(self, nextToken: str=None, maxResults: int=None, nameContains: str=None) -> GetIntentsResponse:
        pass

    def get_slot_type(self, version: str, name: str) -> GetSlotTypeResponse:
        pass

    def get_slot_type_versions(self, name: str, nextToken: str=None, maxResults: int=None) -> GetSlotTypeVersionsResponse:
        pass

    def get_slot_types(self, nextToken: str=None, maxResults: int=None, nameContains: str=None) -> GetSlotTypesResponse:
        pass

    def get_utterances_view(self, statusType: str, botVersions: List[Version], botName: str) -> GetUtterancesViewResponse:
        pass

    def put_bot(self, childDirected: Boolean, locale: str, name: str, description: str=None, intents: List[Intent]=None, clarificationPrompt: Prompt=None, abortStatement: Statement=None, idleSessionTTLInSeconds: int=None, voiceId: str=None, checksum: str=None, processBehavior: str=None, createVersion: Boolean=None) -> PutBotResponse:
        pass

    def put_bot_alias(self, botName: str, botVersion: str, name: str, description: str=None, checksum: str=None) -> PutBotAliasResponse:
        pass

    def put_intent(self, name: str, description: str=None, slots: List[Slot]=None, sampleUtterances: List[Utterance]=None, confirmationPrompt: Prompt=None, rejectionStatement: Statement=None, followUpPrompt: FollowUpPrompt=None, conclusionStatement: Statement=None, dialogCodeHook: CodeHook=None, fulfillmentActivity: FulfillmentActivity=None, parentIntentSignature: str=None, checksum: str=None, createVersion: Boolean=None) -> PutIntentResponse:
        pass

    def put_slot_type(self, name: str, description: str=None, enumerationValues: List[EnumerationValue]=None, checksum: str=None, valueSelectionStrategy: str=None, createVersion: Boolean=None) -> PutSlotTypeResponse:
        pass

    def start_import(self, mergeStrategy: str, resourceType: str, payload: Blob) -> StartImportResponse:
        pass


class LexRuntimeService(BaseClient):
    class PostContentRequest(Mapping):
        pass

    class PostContentResponse(Mapping):
        pass

    class BlobStream(object):
        pass

    class PostTextRequest(Mapping):
        pass

    class PostTextResponse(Mapping):
        pass

    class StringMap(object):
        pass

    def post_content(self, inputStream: BlobStream, contentType: str, userId: str, botAlias: str, botName: str, sessionAttributes: str=None, requestAttributes: str=None, accept: str=None) -> PostContentResponse:
        pass

    def post_text(self, inputText: str, userId: str, botAlias: str, botName: str, sessionAttributes: StringMap=None, requestAttributes: StringMap=None) -> PostTextResponse:
        pass


class LicenseManager(BaseClient):
    class CreateLicenseConfigurationRequest(Mapping):
        pass

    class CreateLicenseConfigurationResponse(Mapping):
        pass

    class BoxLong(object):
        pass

    class BoxBoolean(object):
        pass

    class String(object):
        pass

    class Tag(Mapping):
        pass

    class DeleteLicenseConfigurationRequest(Mapping):
        pass

    class DeleteLicenseConfigurationResponse(Mapping):
        pass

    class GetLicenseConfigurationRequest(Mapping):
        pass

    class GetLicenseConfigurationResponse(Mapping):
        pass

    class GetServiceSettingsRequest(Mapping):
        pass

    class GetServiceSettingsResponse(Mapping):
        pass

    class ListAssociationsForLicenseConfigurationRequest(Mapping):
        pass

    class ListAssociationsForLicenseConfigurationResponse(Mapping):
        pass

    class ListLicenseConfigurationsRequest(Mapping):
        pass

    class ListLicenseConfigurationsResponse(Mapping):
        pass

    class Filter(Mapping):
        pass

    class ListLicenseSpecificationsForResourceRequest(Mapping):
        pass

    class ListLicenseSpecificationsForResourceResponse(Mapping):
        pass

    class ListResourceInventoryRequest(Mapping):
        pass

    class ListResourceInventoryResponse(Mapping):
        pass

    class InventoryFilter(Mapping):
        pass

    class ListTagsForResourceRequest(Mapping):
        pass

    class ListTagsForResourceResponse(Mapping):
        pass

    class ListUsageForLicenseConfigurationRequest(Mapping):
        pass

    class ListUsageForLicenseConfigurationResponse(Mapping):
        pass

    class TagResourceRequest(Mapping):
        pass

    class TagResourceResponse(Mapping):
        pass

    class UntagResourceRequest(Mapping):
        pass

    class UntagResourceResponse(Mapping):
        pass

    class UpdateLicenseConfigurationRequest(Mapping):
        pass

    class UpdateLicenseConfigurationResponse(Mapping):
        pass

    class UpdateLicenseSpecificationsForResourceRequest(Mapping):
        pass

    class UpdateLicenseSpecificationsForResourceResponse(Mapping):
        pass

    class LicenseSpecification(Mapping):
        pass

    class UpdateServiceSettingsRequest(Mapping):
        pass

    class UpdateServiceSettingsResponse(Mapping):
        pass

    class OrganizationConfiguration(Mapping):
        pass

    def create_license_configuration(self, LicenseCountingType: str, Name: str, Description: str=None, LicenseCount: BoxLong=None, LicenseCountHardLimit: BoxBoolean=None, LicenseRules: List[String]=None, Tags: List[Tag]=None) -> CreateLicenseConfigurationResponse:
        pass

    def delete_license_configuration(self, LicenseConfigurationArn: str) -> DeleteLicenseConfigurationResponse:
        pass

    def get_license_configuration(self, LicenseConfigurationArn: str) -> GetLicenseConfigurationResponse:
        pass

    def get_service_settings(self) -> GetServiceSettingsResponse:
        pass

    def list_associations_for_license_configuration(self, LicenseConfigurationArn: str, MaxResults: int=None, NextToken: str=None) -> ListAssociationsForLicenseConfigurationResponse:
        pass

    def list_license_configurations(self, LicenseConfigurationArns: List[String]=None, MaxResults: int=None, NextToken: str=None, Filters: List[Filter]=None) -> ListLicenseConfigurationsResponse:
        pass

    def list_license_specifications_for_resource(self, ResourceArn: str, MaxResults: int=None, NextToken: str=None) -> ListLicenseSpecificationsForResourceResponse:
        pass

    def list_resource_inventory(self, MaxResults: int=None, NextToken: str=None, Filters: List[InventoryFilter]=None) -> ListResourceInventoryResponse:
        pass

    def list_tags_for_resource(self, ResourceArn: str) -> ListTagsForResourceResponse:
        pass

    def list_usage_for_license_configuration(self, LicenseConfigurationArn: str, MaxResults: int=None, NextToken: str=None, Filters: List[Filter]=None) -> ListUsageForLicenseConfigurationResponse:
        pass

    def tag_resource(self, Tags: List[Tag], ResourceArn: str) -> TagResourceResponse:
        pass

    def untag_resource(self, TagKeys: List[String], ResourceArn: str) -> UntagResourceResponse:
        pass

    def update_license_configuration(self, LicenseConfigurationArn: str, LicenseConfigurationStatus: str=None, LicenseRules: List[String]=None, LicenseCount: BoxLong=None, LicenseCountHardLimit: BoxBoolean=None, Name: str=None, Description: str=None) -> UpdateLicenseConfigurationResponse:
        pass

    def update_license_specifications_for_resource(self, ResourceArn: str, AddLicenseSpecifications: List[LicenseSpecification]=None, RemoveLicenseSpecifications: List[LicenseSpecification]=None) -> UpdateLicenseSpecificationsForResourceResponse:
        pass

    def update_service_settings(self, S3BucketArn: str=None, SnsTopicArn: str=None, OrganizationConfiguration: OrganizationConfiguration=None, EnableCrossAccountsDiscovery: BoxBoolean=None) -> UpdateServiceSettingsResponse:
        pass


class Lightsail(BaseClient):
    class AllocateStaticIpRequest(Mapping):
        pass

    class AllocateStaticIpResult(Mapping):
        pass

    class AttachDiskRequest(Mapping):
        pass

    class AttachDiskResult(Mapping):
        pass

    class AttachInstancesToLoadBalancerRequest(Mapping):
        pass

    class AttachInstancesToLoadBalancerResult(Mapping):
        pass

    class ResourceName(object):
        pass

    class AttachLoadBalancerTlsCertificateRequest(Mapping):
        pass

    class AttachLoadBalancerTlsCertificateResult(Mapping):
        pass

    class AttachStaticIpRequest(Mapping):
        pass

    class AttachStaticIpResult(Mapping):
        pass

    class CloseInstancePublicPortsRequest(Mapping):
        pass

    class CloseInstancePublicPortsResult(Mapping):
        pass

    class PortInfo(Mapping):
        pass

    class CopySnapshotRequest(Mapping):
        pass

    class CopySnapshotResult(Mapping):
        pass

    class CreateCloudFormationStackRequest(Mapping):
        pass

    class CreateCloudFormationStackResult(Mapping):
        pass

    class InstanceEntry(Mapping):
        pass

    class CreateDiskRequest(Mapping):
        pass

    class CreateDiskResult(Mapping):
        pass

    class Tag(Mapping):
        pass

    class CreateDiskFromSnapshotRequest(Mapping):
        pass

    class CreateDiskFromSnapshotResult(Mapping):
        pass

    class CreateDiskSnapshotRequest(Mapping):
        pass

    class CreateDiskSnapshotResult(Mapping):
        pass

    class CreateDomainRequest(Mapping):
        pass

    class CreateDomainResult(Mapping):
        pass

    class CreateDomainEntryRequest(Mapping):
        pass

    class CreateDomainEntryResult(Mapping):
        pass

    class DomainEntry(Mapping):
        pass

    class CreateInstanceSnapshotRequest(Mapping):
        pass

    class CreateInstanceSnapshotResult(Mapping):
        pass

    class CreateInstancesRequest(Mapping):
        pass

    class CreateInstancesResult(Mapping):
        pass

    class string(object):
        pass

    class CreateInstancesFromSnapshotRequest(Mapping):
        pass

    class CreateInstancesFromSnapshotResult(Mapping):
        pass

    class AttachedDiskMap(object):
        pass

    class CreateKeyPairRequest(Mapping):
        pass

    class CreateKeyPairResult(Mapping):
        pass

    class CreateLoadBalancerRequest(Mapping):
        pass

    class CreateLoadBalancerResult(Mapping):
        pass

    class DomainName(object):
        pass

    class CreateLoadBalancerTlsCertificateRequest(Mapping):
        pass

    class CreateLoadBalancerTlsCertificateResult(Mapping):
        pass

    class CreateRelationalDatabaseRequest(Mapping):
        pass

    class CreateRelationalDatabaseResult(Mapping):
        pass

    class boolean(object):
        pass

    class CreateRelationalDatabaseFromSnapshotRequest(Mapping):
        pass

    class CreateRelationalDatabaseFromSnapshotResult(Mapping):
        pass

    class IsoDate(object):
        pass

    class CreateRelationalDatabaseSnapshotRequest(Mapping):
        pass

    class CreateRelationalDatabaseSnapshotResult(Mapping):
        pass

    class DeleteDiskRequest(Mapping):
        pass

    class DeleteDiskResult(Mapping):
        pass

    class DeleteDiskSnapshotRequest(Mapping):
        pass

    class DeleteDiskSnapshotResult(Mapping):
        pass

    class DeleteDomainRequest(Mapping):
        pass

    class DeleteDomainResult(Mapping):
        pass

    class DeleteDomainEntryRequest(Mapping):
        pass

    class DeleteDomainEntryResult(Mapping):
        pass

    class DeleteInstanceRequest(Mapping):
        pass

    class DeleteInstanceResult(Mapping):
        pass

    class DeleteInstanceSnapshotRequest(Mapping):
        pass

    class DeleteInstanceSnapshotResult(Mapping):
        pass

    class DeleteKeyPairRequest(Mapping):
        pass

    class DeleteKeyPairResult(Mapping):
        pass

    class DeleteLoadBalancerRequest(Mapping):
        pass

    class DeleteLoadBalancerResult(Mapping):
        pass

    class DeleteLoadBalancerTlsCertificateRequest(Mapping):
        pass

    class DeleteLoadBalancerTlsCertificateResult(Mapping):
        pass

    class DeleteRelationalDatabaseRequest(Mapping):
        pass

    class DeleteRelationalDatabaseResult(Mapping):
        pass

    class DeleteRelationalDatabaseSnapshotRequest(Mapping):
        pass

    class DeleteRelationalDatabaseSnapshotResult(Mapping):
        pass

    class DetachDiskRequest(Mapping):
        pass

    class DetachDiskResult(Mapping):
        pass

    class DetachInstancesFromLoadBalancerRequest(Mapping):
        pass

    class DetachInstancesFromLoadBalancerResult(Mapping):
        pass

    class DetachStaticIpRequest(Mapping):
        pass

    class DetachStaticIpResult(Mapping):
        pass

    class DownloadDefaultKeyPairRequest(Mapping):
        pass

    class DownloadDefaultKeyPairResult(Mapping):
        pass

    class ExportSnapshotRequest(Mapping):
        pass

    class ExportSnapshotResult(Mapping):
        pass

    class GetActiveNamesRequest(Mapping):
        pass

    class GetActiveNamesResult(Mapping):
        pass

    class GetBlueprintsRequest(Mapping):
        pass

    class GetBlueprintsResult(Mapping):
        pass

    class GetBundlesRequest(Mapping):
        pass

    class GetBundlesResult(Mapping):
        pass

    class GetCloudFormationStackRecordsRequest(Mapping):
        pass

    class GetCloudFormationStackRecordsResult(Mapping):
        pass

    class GetDiskRequest(Mapping):
        pass

    class GetDiskResult(Mapping):
        pass

    class GetDiskSnapshotRequest(Mapping):
        pass

    class GetDiskSnapshotResult(Mapping):
        pass

    class GetDiskSnapshotsRequest(Mapping):
        pass

    class GetDiskSnapshotsResult(Mapping):
        pass

    class GetDisksRequest(Mapping):
        pass

    class GetDisksResult(Mapping):
        pass

    class GetDomainRequest(Mapping):
        pass

    class GetDomainResult(Mapping):
        pass

    class GetDomainsRequest(Mapping):
        pass

    class GetDomainsResult(Mapping):
        pass

    class GetExportSnapshotRecordsRequest(Mapping):
        pass

    class GetExportSnapshotRecordsResult(Mapping):
        pass

    class GetInstanceRequest(Mapping):
        pass

    class GetInstanceResult(Mapping):
        pass

    class GetInstanceAccessDetailsRequest(Mapping):
        pass

    class GetInstanceAccessDetailsResult(Mapping):
        pass

    class GetInstanceMetricDataRequest(Mapping):
        pass

    class GetInstanceMetricDataResult(Mapping):
        pass

    class timestamp(object):
        pass

    class MetricStatistic(object):
        pass

    class GetInstancePortStatesRequest(Mapping):
        pass

    class GetInstancePortStatesResult(Mapping):
        pass

    class GetInstanceSnapshotRequest(Mapping):
        pass

    class GetInstanceSnapshotResult(Mapping):
        pass

    class GetInstanceSnapshotsRequest(Mapping):
        pass

    class GetInstanceSnapshotsResult(Mapping):
        pass

    class GetInstanceStateRequest(Mapping):
        pass

    class GetInstanceStateResult(Mapping):
        pass

    class GetInstancesRequest(Mapping):
        pass

    class GetInstancesResult(Mapping):
        pass

    class GetKeyPairRequest(Mapping):
        pass

    class GetKeyPairResult(Mapping):
        pass

    class GetKeyPairsRequest(Mapping):
        pass

    class GetKeyPairsResult(Mapping):
        pass

    class GetLoadBalancerRequest(Mapping):
        pass

    class GetLoadBalancerResult(Mapping):
        pass

    class GetLoadBalancerMetricDataRequest(Mapping):
        pass

    class GetLoadBalancerMetricDataResult(Mapping):
        pass

    class GetLoadBalancerTlsCertificatesRequest(Mapping):
        pass

    class GetLoadBalancerTlsCertificatesResult(Mapping):
        pass

    class GetLoadBalancersRequest(Mapping):
        pass

    class GetLoadBalancersResult(Mapping):
        pass

    class GetOperationRequest(Mapping):
        pass

    class GetOperationResult(Mapping):
        pass

    class GetOperationsRequest(Mapping):
        pass

    class GetOperationsResult(Mapping):
        pass

    class GetOperationsForResourceRequest(Mapping):
        pass

    class GetOperationsForResourceResult(Mapping):
        pass

    class GetRegionsRequest(Mapping):
        pass

    class GetRegionsResult(Mapping):
        pass

    class GetRelationalDatabaseRequest(Mapping):
        pass

    class GetRelationalDatabaseResult(Mapping):
        pass

    class GetRelationalDatabaseBlueprintsRequest(Mapping):
        pass

    class GetRelationalDatabaseBlueprintsResult(Mapping):
        pass

    class GetRelationalDatabaseBundlesRequest(Mapping):
        pass

    class GetRelationalDatabaseBundlesResult(Mapping):
        pass

    class GetRelationalDatabaseEventsRequest(Mapping):
        pass

    class GetRelationalDatabaseEventsResult(Mapping):
        pass

    class GetRelationalDatabaseLogEventsRequest(Mapping):
        pass

    class GetRelationalDatabaseLogEventsResult(Mapping):
        pass

    class GetRelationalDatabaseLogStreamsRequest(Mapping):
        pass

    class GetRelationalDatabaseLogStreamsResult(Mapping):
        pass

    class GetRelationalDatabaseMasterUserPasswordRequest(Mapping):
        pass

    class GetRelationalDatabaseMasterUserPasswordResult(Mapping):
        pass

    class GetRelationalDatabaseMetricDataRequest(Mapping):
        pass

    class GetRelationalDatabaseMetricDataResult(Mapping):
        pass

    class GetRelationalDatabaseParametersRequest(Mapping):
        pass

    class GetRelationalDatabaseParametersResult(Mapping):
        pass

    class GetRelationalDatabaseSnapshotRequest(Mapping):
        pass

    class GetRelationalDatabaseSnapshotResult(Mapping):
        pass

    class GetRelationalDatabaseSnapshotsRequest(Mapping):
        pass

    class GetRelationalDatabaseSnapshotsResult(Mapping):
        pass

    class GetRelationalDatabasesRequest(Mapping):
        pass

    class GetRelationalDatabasesResult(Mapping):
        pass

    class GetStaticIpRequest(Mapping):
        pass

    class GetStaticIpResult(Mapping):
        pass

    class GetStaticIpsRequest(Mapping):
        pass

    class GetStaticIpsResult(Mapping):
        pass

    class ImportKeyPairRequest(Mapping):
        pass

    class ImportKeyPairResult(Mapping):
        pass

    class IsVpcPeeredRequest(Mapping):
        pass

    class IsVpcPeeredResult(Mapping):
        pass

    class OpenInstancePublicPortsRequest(Mapping):
        pass

    class OpenInstancePublicPortsResult(Mapping):
        pass

    class PeerVpcRequest(Mapping):
        pass

    class PeerVpcResult(Mapping):
        pass

    class PutInstancePublicPortsRequest(Mapping):
        pass

    class PutInstancePublicPortsResult(Mapping):
        pass

    class RebootInstanceRequest(Mapping):
        pass

    class RebootInstanceResult(Mapping):
        pass

    class RebootRelationalDatabaseRequest(Mapping):
        pass

    class RebootRelationalDatabaseResult(Mapping):
        pass

    class ReleaseStaticIpRequest(Mapping):
        pass

    class ReleaseStaticIpResult(Mapping):
        pass

    class StartInstanceRequest(Mapping):
        pass

    class StartInstanceResult(Mapping):
        pass

    class StartRelationalDatabaseRequest(Mapping):
        pass

    class StartRelationalDatabaseResult(Mapping):
        pass

    class StopInstanceRequest(Mapping):
        pass

    class StopInstanceResult(Mapping):
        pass

    class StopRelationalDatabaseRequest(Mapping):
        pass

    class StopRelationalDatabaseResult(Mapping):
        pass

    class TagResourceRequest(Mapping):
        pass

    class TagResourceResult(Mapping):
        pass

    class UnpeerVpcRequest(Mapping):
        pass

    class UnpeerVpcResult(Mapping):
        pass

    class UntagResourceRequest(Mapping):
        pass

    class UntagResourceResult(Mapping):
        pass

    class TagKey(object):
        pass

    class UpdateDomainEntryRequest(Mapping):
        pass

    class UpdateDomainEntryResult(Mapping):
        pass

    class UpdateLoadBalancerAttributeRequest(Mapping):
        pass

    class UpdateLoadBalancerAttributeResult(Mapping):
        pass

    class UpdateRelationalDatabaseRequest(Mapping):
        pass

    class UpdateRelationalDatabaseResult(Mapping):
        pass

    class UpdateRelationalDatabaseParametersRequest(Mapping):
        pass

    class UpdateRelationalDatabaseParametersResult(Mapping):
        pass

    class RelationalDatabaseParameter(Mapping):
        pass

    def allocate_static_ip(self, staticIpName: str) -> AllocateStaticIpResult:
        pass

    def attach_disk(self, diskPath: str, instanceName: str, diskName: str) -> AttachDiskResult:
        pass

    def attach_instances_to_load_balancer(self, instanceNames: List[ResourceName], loadBalancerName: str) -> AttachInstancesToLoadBalancerResult:
        pass

    def attach_load_balancer_tls_certificate(self, certificateName: str, loadBalancerName: str) -> AttachLoadBalancerTlsCertificateResult:
        pass

    def attach_static_ip(self, instanceName: str, staticIpName: str) -> AttachStaticIpResult:
        pass

    def close_instance_public_ports(self, instanceName: str, portInfo: PortInfo) -> CloseInstancePublicPortsResult:
        pass

    def copy_snapshot(self, sourceRegion: str, targetSnapshotName: str, sourceSnapshotName: str) -> CopySnapshotResult:
        pass

    def create_cloud_formation_stack(self, instances: List[InstanceEntry]) -> CreateCloudFormationStackResult:
        pass

    def create_disk(self, sizeInGb: int, availabilityZone: str, diskName: str, tags: List[Tag]=None) -> CreateDiskResult:
        pass

    def create_disk_from_snapshot(self, sizeInGb: int, availabilityZone: str, diskSnapshotName: str, diskName: str, tags: List[Tag]=None) -> CreateDiskFromSnapshotResult:
        pass

    def create_disk_snapshot(self, diskSnapshotName: str, diskName: str=None, instanceName: str=None, tags: List[Tag]=None) -> CreateDiskSnapshotResult:
        pass

    def create_domain(self, domainName: str, tags: List[Tag]=None) -> CreateDomainResult:
        pass

    def create_domain_entry(self, domainEntry: DomainEntry, domainName: str) -> CreateDomainEntryResult:
        pass

    def create_instance_snapshot(self, instanceName: str, instanceSnapshotName: str, tags: List[Tag]=None) -> CreateInstanceSnapshotResult:
        pass

    def create_instances(self, bundleId: str, blueprintId: str, availabilityZone: str, instanceNames: List[string], customImageName: str=None, userData: str=None, keyPairName: str=None, tags: List[Tag]=None) -> CreateInstancesResult:
        pass

    def create_instances_from_snapshot(self, bundleId: str, instanceSnapshotName: str, availabilityZone: str, instanceNames: List[string], attachedDiskMapping: AttachedDiskMap=None, userData: str=None, keyPairName: str=None, tags: List[Tag]=None) -> CreateInstancesFromSnapshotResult:
        pass

    def create_key_pair(self, keyPairName: str, tags: List[Tag]=None) -> CreateKeyPairResult:
        pass

    def create_load_balancer(self, instancePort: int, loadBalancerName: str, healthCheckPath: str=None, certificateName: str=None, certificateDomainName: str=None, certificateAlternativeNames: List[DomainName]=None, tags: List[Tag]=None) -> CreateLoadBalancerResult:
        pass

    def create_load_balancer_tls_certificate(self, certificateDomainName: str, certificateName: str, loadBalancerName: str, certificateAlternativeNames: List[DomainName]=None, tags: List[Tag]=None) -> CreateLoadBalancerTlsCertificateResult:
        pass

    def create_relational_database(self, masterUsername: str, masterDatabaseName: str, relationalDatabaseBundleId: str, relationalDatabaseBlueprintId: str, relationalDatabaseName: str, availabilityZone: str=None, masterUserPassword: str=None, preferredBackupWindow: str=None, preferredMaintenanceWindow: str=None, publiclyAccessible: boolean=None, tags: List[Tag]=None) -> CreateRelationalDatabaseResult:
        pass

    def create_relational_database_from_snapshot(self, relationalDatabaseName: str, availabilityZone: str=None, publiclyAccessible: boolean=None, relationalDatabaseSnapshotName: str=None, relationalDatabaseBundleId: str=None, sourceRelationalDatabaseName: str=None, restoreTime: IsoDate=None, useLatestRestorableTime: boolean=None, tags: List[Tag]=None) -> CreateRelationalDatabaseFromSnapshotResult:
        pass

    def create_relational_database_snapshot(self, relationalDatabaseSnapshotName: str, relationalDatabaseName: str, tags: List[Tag]=None) -> CreateRelationalDatabaseSnapshotResult:
        pass

    def delete_disk(self, diskName: str) -> DeleteDiskResult:
        pass

    def delete_disk_snapshot(self, diskSnapshotName: str) -> DeleteDiskSnapshotResult:
        pass

    def delete_domain(self, domainName: str) -> DeleteDomainResult:
        pass

    def delete_domain_entry(self, domainEntry: DomainEntry, domainName: str) -> DeleteDomainEntryResult:
        pass

    def delete_instance(self, instanceName: str) -> DeleteInstanceResult:
        pass

    def delete_instance_snapshot(self, instanceSnapshotName: str) -> DeleteInstanceSnapshotResult:
        pass

    def delete_key_pair(self, keyPairName: str) -> DeleteKeyPairResult:
        pass

    def delete_load_balancer(self, loadBalancerName: str) -> DeleteLoadBalancerResult:
        pass

    def delete_load_balancer_tls_certificate(self, certificateName: str, loadBalancerName: str, force: boolean=None) -> DeleteLoadBalancerTlsCertificateResult:
        pass

    def delete_relational_database(self, relationalDatabaseName: str, skipFinalSnapshot: boolean=None, finalRelationalDatabaseSnapshotName: str=None) -> DeleteRelationalDatabaseResult:
        pass

    def delete_relational_database_snapshot(self, relationalDatabaseSnapshotName: str) -> DeleteRelationalDatabaseSnapshotResult:
        pass

    def detach_disk(self, diskName: str) -> DetachDiskResult:
        pass

    def detach_instances_from_load_balancer(self, instanceNames: List[ResourceName], loadBalancerName: str) -> DetachInstancesFromLoadBalancerResult:
        pass

    def detach_static_ip(self, staticIpName: str) -> DetachStaticIpResult:
        pass

    def download_default_key_pair(self) -> DownloadDefaultKeyPairResult:
        pass

    def export_snapshot(self, sourceSnapshotName: str) -> ExportSnapshotResult:
        pass

    def get_active_names(self, pageToken: str=None) -> GetActiveNamesResult:
        pass

    def get_blueprints(self, includeInactive: boolean=None, pageToken: str=None) -> GetBlueprintsResult:
        pass

    def get_bundles(self, includeInactive: boolean=None, pageToken: str=None) -> GetBundlesResult:
        pass

    def get_cloud_formation_stack_records(self, pageToken: str=None) -> GetCloudFormationStackRecordsResult:
        pass

    def get_disk(self, diskName: str) -> GetDiskResult:
        pass

    def get_disk_snapshot(self, diskSnapshotName: str) -> GetDiskSnapshotResult:
        pass

    def get_disk_snapshots(self, pageToken: str=None) -> GetDiskSnapshotsResult:
        pass

    def get_disks(self, pageToken: str=None) -> GetDisksResult:
        pass

    def get_domain(self, domainName: str) -> GetDomainResult:
        pass

    def get_domains(self, pageToken: str=None) -> GetDomainsResult:
        pass

    def get_export_snapshot_records(self, pageToken: str=None) -> GetExportSnapshotRecordsResult:
        pass

    def get_instance(self, instanceName: str) -> GetInstanceResult:
        pass

    def get_instance_access_details(self, instanceName: str, protocol: str=None) -> GetInstanceAccessDetailsResult:
        pass

    def get_instance_metric_data(self, statistics: List[MetricStatistic], unit: str, endTime: timestamp, startTime: timestamp, period: int, metricName: str, instanceName: str) -> GetInstanceMetricDataResult:
        pass

    def get_instance_port_states(self, instanceName: str) -> GetInstancePortStatesResult:
        pass

    def get_instance_snapshot(self, instanceSnapshotName: str) -> GetInstanceSnapshotResult:
        pass

    def get_instance_snapshots(self, pageToken: str=None) -> GetInstanceSnapshotsResult:
        pass

    def get_instance_state(self, instanceName: str) -> GetInstanceStateResult:
        pass

    def get_instances(self, pageToken: str=None) -> GetInstancesResult:
        pass

    def get_key_pair(self, keyPairName: str) -> GetKeyPairResult:
        pass

    def get_key_pairs(self, pageToken: str=None) -> GetKeyPairsResult:
        pass

    def get_load_balancer(self, loadBalancerName: str) -> GetLoadBalancerResult:
        pass

    def get_load_balancer_metric_data(self, statistics: List[MetricStatistic], unit: str, endTime: timestamp, startTime: timestamp, period: int, metricName: str, loadBalancerName: str) -> GetLoadBalancerMetricDataResult:
        pass

    def get_load_balancer_tls_certificates(self, loadBalancerName: str) -> GetLoadBalancerTlsCertificatesResult:
        pass

    def get_load_balancers(self, pageToken: str=None) -> GetLoadBalancersResult:
        pass

    def get_operation(self, operationId: str) -> GetOperationResult:
        pass

    def get_operations(self, pageToken: str=None) -> GetOperationsResult:
        pass

    def get_operations_for_resource(self, resourceName: str, pageToken: str=None) -> GetOperationsForResourceResult:
        pass

    def get_regions(self, includeAvailabilityZones: boolean=None, includeRelationalDatabaseAvailabilityZones: boolean=None) -> GetRegionsResult:
        pass

    def get_relational_database(self, relationalDatabaseName: str) -> GetRelationalDatabaseResult:
        pass

    def get_relational_database_blueprints(self, pageToken: str=None) -> GetRelationalDatabaseBlueprintsResult:
        pass

    def get_relational_database_bundles(self, pageToken: str=None) -> GetRelationalDatabaseBundlesResult:
        pass

    def get_relational_database_events(self, relationalDatabaseName: str, durationInMinutes: int=None, pageToken: str=None) -> GetRelationalDatabaseEventsResult:
        pass

    def get_relational_database_log_events(self, logStreamName: str, relationalDatabaseName: str, startTime: IsoDate=None, endTime: IsoDate=None, startFromHead: boolean=None, pageToken: str=None) -> GetRelationalDatabaseLogEventsResult:
        pass

    def get_relational_database_log_streams(self, relationalDatabaseName: str) -> GetRelationalDatabaseLogStreamsResult:
        pass

    def get_relational_database_master_user_password(self, relationalDatabaseName: str, passwordVersion: str=None) -> GetRelationalDatabaseMasterUserPasswordResult:
        pass

    def get_relational_database_metric_data(self, statistics: List[MetricStatistic], unit: str, endTime: IsoDate, startTime: IsoDate, period: int, metricName: str, relationalDatabaseName: str) -> GetRelationalDatabaseMetricDataResult:
        pass

    def get_relational_database_parameters(self, relationalDatabaseName: str, pageToken: str=None) -> GetRelationalDatabaseParametersResult:
        pass

    def get_relational_database_snapshot(self, relationalDatabaseSnapshotName: str) -> GetRelationalDatabaseSnapshotResult:
        pass

    def get_relational_database_snapshots(self, pageToken: str=None) -> GetRelationalDatabaseSnapshotsResult:
        pass

    def get_relational_databases(self, pageToken: str=None) -> GetRelationalDatabasesResult:
        pass

    def get_static_ip(self, staticIpName: str) -> GetStaticIpResult:
        pass

    def get_static_ips(self, pageToken: str=None) -> GetStaticIpsResult:
        pass

    def import_key_pair(self, publicKeyBase64: str, keyPairName: str) -> ImportKeyPairResult:
        pass

    def is_vpc_peered(self) -> IsVpcPeeredResult:
        pass

    def open_instance_public_ports(self, instanceName: str, portInfo: PortInfo) -> OpenInstancePublicPortsResult:
        pass

    def peer_vpc(self) -> PeerVpcResult:
        pass

    def put_instance_public_ports(self, instanceName: str, portInfos: List[PortInfo]) -> PutInstancePublicPortsResult:
        pass

    def reboot_instance(self, instanceName: str) -> RebootInstanceResult:
        pass

    def reboot_relational_database(self, relationalDatabaseName: str) -> RebootRelationalDatabaseResult:
        pass

    def release_static_ip(self, staticIpName: str) -> ReleaseStaticIpResult:
        pass

    def start_instance(self, instanceName: str) -> StartInstanceResult:
        pass

    def start_relational_database(self, relationalDatabaseName: str) -> StartRelationalDatabaseResult:
        pass

    def stop_instance(self, instanceName: str, force: boolean=None) -> StopInstanceResult:
        pass

    def stop_relational_database(self, relationalDatabaseName: str, relationalDatabaseSnapshotName: str=None) -> StopRelationalDatabaseResult:
        pass

    def tag_resource(self, tags: List[Tag], resourceName: str) -> TagResourceResult:
        pass

    def unpeer_vpc(self) -> UnpeerVpcResult:
        pass

    def untag_resource(self, tagKeys: List[TagKey], resourceName: str) -> UntagResourceResult:
        pass

    def update_domain_entry(self, domainEntry: DomainEntry, domainName: str) -> UpdateDomainEntryResult:
        pass

    def update_load_balancer_attribute(self, attributeValue: str, attributeName: str, loadBalancerName: str) -> UpdateLoadBalancerAttributeResult:
        pass

    def update_relational_database(self, relationalDatabaseName: str, masterUserPassword: str=None, rotateMasterUserPassword: boolean=None, preferredBackupWindow: str=None, preferredMaintenanceWindow: str=None, enableBackupRetention: boolean=None, disableBackupRetention: boolean=None, publiclyAccessible: boolean=None, applyImmediately: boolean=None) -> UpdateRelationalDatabaseResult:
        pass

    def update_relational_database_parameters(self, parameters: List[RelationalDatabaseParameter], relationalDatabaseName: str) -> UpdateRelationalDatabaseParametersResult:
        pass


class CloudWatchLogs(BaseClient):
    class AssociateKmsKeyRequest(Mapping):
        pass

    class CancelExportTaskRequest(Mapping):
        pass

    class CreateExportTaskRequest(Mapping):
        pass

    class CreateExportTaskResponse(Mapping):
        pass

    class Timestamp(object):
        pass

    class CreateLogGroupRequest(Mapping):
        pass

    class Tags(object):
        pass

    class CreateLogStreamRequest(Mapping):
        pass

    class DeleteDestinationRequest(Mapping):
        pass

    class DeleteLogGroupRequest(Mapping):
        pass

    class DeleteLogStreamRequest(Mapping):
        pass

    class DeleteMetricFilterRequest(Mapping):
        pass

    class DeleteResourcePolicyRequest(Mapping):
        pass

    class DeleteRetentionPolicyRequest(Mapping):
        pass

    class DeleteSubscriptionFilterRequest(Mapping):
        pass

    class DescribeDestinationsRequest(Mapping):
        pass

    class DescribeDestinationsResponse(Mapping):
        pass

    class DescribeExportTasksRequest(Mapping):
        pass

    class DescribeExportTasksResponse(Mapping):
        pass

    class DescribeLogGroupsRequest(Mapping):
        pass

    class DescribeLogGroupsResponse(Mapping):
        pass

    class DescribeLogStreamsRequest(Mapping):
        pass

    class DescribeLogStreamsResponse(Mapping):
        pass

    class Descending(object):
        pass

    class DescribeMetricFiltersRequest(Mapping):
        pass

    class DescribeMetricFiltersResponse(Mapping):
        pass

    class DescribeQueriesRequest(Mapping):
        pass

    class DescribeQueriesResponse(Mapping):
        pass

    class DescribeResourcePoliciesRequest(Mapping):
        pass

    class DescribeResourcePoliciesResponse(Mapping):
        pass

    class DescribeSubscriptionFiltersRequest(Mapping):
        pass

    class DescribeSubscriptionFiltersResponse(Mapping):
        pass

    class DisassociateKmsKeyRequest(Mapping):
        pass

    class FilterLogEventsRequest(Mapping):
        pass

    class FilterLogEventsResponse(Mapping):
        pass

    class LogStreamName(object):
        pass

    class Interleaved(object):
        pass

    class GetLogEventsRequest(Mapping):
        pass

    class GetLogEventsResponse(Mapping):
        pass

    class StartFromHead(object):
        pass

    class GetLogGroupFieldsRequest(Mapping):
        pass

    class GetLogGroupFieldsResponse(Mapping):
        pass

    class GetLogRecordRequest(Mapping):
        pass

    class GetLogRecordResponse(Mapping):
        pass

    class GetQueryResultsRequest(Mapping):
        pass

    class GetQueryResultsResponse(Mapping):
        pass

    class ListTagsLogGroupRequest(Mapping):
        pass

    class ListTagsLogGroupResponse(Mapping):
        pass

    class PutDestinationRequest(Mapping):
        pass

    class PutDestinationResponse(Mapping):
        pass

    class PutDestinationPolicyRequest(Mapping):
        pass

    class PutLogEventsRequest(Mapping):
        pass

    class PutLogEventsResponse(Mapping):
        pass

    class InputLogEvent(Mapping):
        pass

    class PutMetricFilterRequest(Mapping):
        pass

    class MetricTransformation(Mapping):
        pass

    class PutResourcePolicyRequest(Mapping):
        pass

    class PutResourcePolicyResponse(Mapping):
        pass

    class PutRetentionPolicyRequest(Mapping):
        pass

    class PutSubscriptionFilterRequest(Mapping):
        pass

    class StartQueryRequest(Mapping):
        pass

    class StartQueryResponse(Mapping):
        pass

    class StopQueryRequest(Mapping):
        pass

    class StopQueryResponse(Mapping):
        pass

    class TagLogGroupRequest(Mapping):
        pass

    class TestMetricFilterRequest(Mapping):
        pass

    class TestMetricFilterResponse(Mapping):
        pass

    class EventMessage(object):
        pass

    class UntagLogGroupRequest(Mapping):
        pass

    class TagKey(object):
        pass

    def associate_kms_key(self, kmsKeyId: str, logGroupName: str):
        pass

    def cancel_export_task(self, taskId: str):
        pass

    def create_export_task(self, destination: str, to: Timestamp, from_: Timestamp, logGroupName: str, taskName: str=None, logStreamNamePrefix: str=None, destinationPrefix: str=None) -> CreateExportTaskResponse:
        pass

    def create_log_group(self, logGroupName: str, kmsKeyId: str=None, tags: Tags=None):
        pass

    def create_log_stream(self, logStreamName: str, logGroupName: str):
        pass

    def delete_destination(self, destinationName: str):
        pass

    def delete_log_group(self, logGroupName: str):
        pass

    def delete_log_stream(self, logStreamName: str, logGroupName: str):
        pass

    def delete_metric_filter(self, filterName: str, logGroupName: str):
        pass

    def delete_resource_policy(self, policyName: str=None):
        pass

    def delete_retention_policy(self, logGroupName: str):
        pass

    def delete_subscription_filter(self, filterName: str, logGroupName: str):
        pass

    def describe_destinations(self, DestinationNamePrefix: str=None, nextToken: str=None, limit: int=None) -> DescribeDestinationsResponse:
        pass

    def describe_export_tasks(self, taskId: str=None, statusCode: str=None, nextToken: str=None, limit: int=None) -> DescribeExportTasksResponse:
        pass

    def describe_log_groups(self, logGroupNamePrefix: str=None, nextToken: str=None, limit: int=None) -> DescribeLogGroupsResponse:
        pass

    def describe_log_streams(self, logGroupName: str, logStreamNamePrefix: str=None, orderBy: str=None, descending: Descending=None, nextToken: str=None, limit: int=None) -> DescribeLogStreamsResponse:
        pass

    def describe_metric_filters(self, logGroupName: str=None, filterNamePrefix: str=None, nextToken: str=None, limit: int=None, metricName: str=None, metricNamespace: str=None) -> DescribeMetricFiltersResponse:
        pass

    def describe_queries(self, logGroupName: str=None, status: str=None, maxResults: int=None, nextToken: str=None) -> DescribeQueriesResponse:
        pass

    def describe_resource_policies(self, nextToken: str=None, limit: int=None) -> DescribeResourcePoliciesResponse:
        pass

    def describe_subscription_filters(self, logGroupName: str, filterNamePrefix: str=None, nextToken: str=None, limit: int=None) -> DescribeSubscriptionFiltersResponse:
        pass

    def disassociate_kms_key(self, logGroupName: str):
        pass

    def filter_log_events(self, logGroupName: str, logStreamNames: List[LogStreamName]=None, logStreamNamePrefix: str=None, startTime: Timestamp=None, endTime: Timestamp=None, filterPattern: str=None, nextToken: str=None, limit: int=None, interleaved: Interleaved=None) -> FilterLogEventsResponse:
        pass

    def get_log_events(self, logStreamName: str, logGroupName: str, startTime: Timestamp=None, endTime: Timestamp=None, nextToken: str=None, limit: int=None, startFromHead: StartFromHead=None) -> GetLogEventsResponse:
        pass

    def get_log_group_fields(self, logGroupName: str, time: Timestamp=None) -> GetLogGroupFieldsResponse:
        pass

    def get_log_record(self, logRecordPointer: str) -> GetLogRecordResponse:
        pass

    def get_query_results(self, queryId: str) -> GetQueryResultsResponse:
        pass

    def list_tags_log_group(self, logGroupName: str) -> ListTagsLogGroupResponse:
        pass

    def put_destination(self, roleArn: str, targetArn: str, destinationName: str) -> PutDestinationResponse:
        pass

    def put_destination_policy(self, accessPolicy: str, destinationName: str):
        pass

    def put_log_events(self, logEvents: List[InputLogEvent], logStreamName: str, logGroupName: str, sequenceToken: str=None) -> PutLogEventsResponse:
        pass

    def put_metric_filter(self, metricTransformations: List[MetricTransformation], filterPattern: str, filterName: str, logGroupName: str):
        pass

    def put_resource_policy(self, policyName: str=None, policyDocument: str=None) -> PutResourcePolicyResponse:
        pass

    def put_retention_policy(self, retentionInDays: int, logGroupName: str):
        pass

    def put_subscription_filter(self, destinationArn: str, filterPattern: str, filterName: str, logGroupName: str, roleArn: str=None, distribution: str=None):
        pass

    def start_query(self, queryString: str, endTime: Timestamp, startTime: Timestamp, logGroupName: str, limit: int=None) -> StartQueryResponse:
        pass

    def stop_query(self, queryId: str) -> StopQueryResponse:
        pass

    def tag_log_group(self, tags: Tags, logGroupName: str):
        pass

    def test_metric_filter(self, logEventMessages: List[EventMessage], filterPattern: str) -> TestMetricFilterResponse:
        pass

    def untag_log_group(self, tags: List[TagKey], logGroupName: str):
        pass


class MachineLearning(BaseClient):
    class AddTagsInput(Mapping):
        pass

    class AddTagsOutput(Mapping):
        pass

    class Tag(Mapping):
        pass

    class CreateBatchPredictionInput(Mapping):
        pass

    class CreateBatchPredictionOutput(Mapping):
        pass

    class CreateDataSourceFromRDSInput(Mapping):
        pass

    class CreateDataSourceFromRDSOutput(Mapping):
        pass

    class RDSDataSpec(Mapping):
        pass

    class ComputeStatistics(object):
        pass

    class CreateDataSourceFromRedshiftInput(Mapping):
        pass

    class CreateDataSourceFromRedshiftOutput(Mapping):
        pass

    class RedshiftDataSpec(Mapping):
        pass

    class CreateDataSourceFromS3Input(Mapping):
        pass

    class CreateDataSourceFromS3Output(Mapping):
        pass

    class S3DataSpec(Mapping):
        pass

    class CreateEvaluationInput(Mapping):
        pass

    class CreateEvaluationOutput(Mapping):
        pass

    class CreateMLModelInput(Mapping):
        pass

    class CreateMLModelOutput(Mapping):
        pass

    class TrainingParameters(object):
        pass

    class CreateRealtimeEndpointInput(Mapping):
        pass

    class CreateRealtimeEndpointOutput(Mapping):
        pass

    class DeleteBatchPredictionInput(Mapping):
        pass

    class DeleteBatchPredictionOutput(Mapping):
        pass

    class DeleteDataSourceInput(Mapping):
        pass

    class DeleteDataSourceOutput(Mapping):
        pass

    class DeleteEvaluationInput(Mapping):
        pass

    class DeleteEvaluationOutput(Mapping):
        pass

    class DeleteMLModelInput(Mapping):
        pass

    class DeleteMLModelOutput(Mapping):
        pass

    class DeleteRealtimeEndpointInput(Mapping):
        pass

    class DeleteRealtimeEndpointOutput(Mapping):
        pass

    class DeleteTagsInput(Mapping):
        pass

    class DeleteTagsOutput(Mapping):
        pass

    class TagKey(object):
        pass

    class DescribeBatchPredictionsInput(Mapping):
        pass

    class DescribeBatchPredictionsOutput(Mapping):
        pass

    class DescribeDataSourcesInput(Mapping):
        pass

    class DescribeDataSourcesOutput(Mapping):
        pass

    class DescribeEvaluationsInput(Mapping):
        pass

    class DescribeEvaluationsOutput(Mapping):
        pass

    class DescribeMLModelsInput(Mapping):
        pass

    class DescribeMLModelsOutput(Mapping):
        pass

    class DescribeTagsInput(Mapping):
        pass

    class DescribeTagsOutput(Mapping):
        pass

    class GetBatchPredictionInput(Mapping):
        pass

    class GetBatchPredictionOutput(Mapping):
        pass

    class GetDataSourceInput(Mapping):
        pass

    class GetDataSourceOutput(Mapping):
        pass

    class Verbose(object):
        pass

    class GetEvaluationInput(Mapping):
        pass

    class GetEvaluationOutput(Mapping):
        pass

    class GetMLModelInput(Mapping):
        pass

    class GetMLModelOutput(Mapping):
        pass

    class PredictInput(Mapping):
        pass

    class PredictOutput(Mapping):
        pass

    class Record(object):
        pass

    class UpdateBatchPredictionInput(Mapping):
        pass

    class UpdateBatchPredictionOutput(Mapping):
        pass

    class UpdateDataSourceInput(Mapping):
        pass

    class UpdateDataSourceOutput(Mapping):
        pass

    class UpdateEvaluationInput(Mapping):
        pass

    class UpdateEvaluationOutput(Mapping):
        pass

    class UpdateMLModelInput(Mapping):
        pass

    class UpdateMLModelOutput(Mapping):
        pass

    class ScoreThreshold(object):
        pass

    def add_tags(self, ResourceType: str, ResourceId: str, Tags: List[Tag]) -> AddTagsOutput:
        pass

    def create_batch_prediction(self, OutputUri: str, BatchPredictionDataSourceId: str, MLModelId: str, BatchPredictionId: str, BatchPredictionName: str=None) -> CreateBatchPredictionOutput:
        pass

    def create_data_source_from_rds(self, RoleARN: str, RDSData: RDSDataSpec, DataSourceId: str, DataSourceName: str=None, ComputeStatistics: ComputeStatistics=None) -> CreateDataSourceFromRDSOutput:
        pass

    def create_data_source_from_redshift(self, RoleARN: str, DataSpec: RedshiftDataSpec, DataSourceId: str, DataSourceName: str=None, ComputeStatistics: ComputeStatistics=None) -> CreateDataSourceFromRedshiftOutput:
        pass

    def create_data_source_from_s3(self, DataSpec: S3DataSpec, DataSourceId: str, DataSourceName: str=None, ComputeStatistics: ComputeStatistics=None) -> CreateDataSourceFromS3Output:
        pass

    def create_evaluation(self, EvaluationDataSourceId: str, MLModelId: str, EvaluationId: str, EvaluationName: str=None) -> CreateEvaluationOutput:
        pass

    def create_ml_model(self, TrainingDataSourceId: str, MLModelType: str, MLModelId: str, MLModelName: str=None, Parameters: TrainingParameters=None, Recipe: str=None, RecipeUri: str=None) -> CreateMLModelOutput:
        pass

    def create_realtime_endpoint(self, MLModelId: str) -> CreateRealtimeEndpointOutput:
        pass

    def delete_batch_prediction(self, BatchPredictionId: str) -> DeleteBatchPredictionOutput:
        pass

    def delete_data_source(self, DataSourceId: str) -> DeleteDataSourceOutput:
        pass

    def delete_evaluation(self, EvaluationId: str) -> DeleteEvaluationOutput:
        pass

    def delete_ml_model(self, MLModelId: str) -> DeleteMLModelOutput:
        pass

    def delete_realtime_endpoint(self, MLModelId: str) -> DeleteRealtimeEndpointOutput:
        pass

    def delete_tags(self, ResourceType: str, ResourceId: str, TagKeys: List[TagKey]) -> DeleteTagsOutput:
        pass

    def describe_batch_predictions(self, FilterVariable: str=None, EQ: str=None, GT: str=None, LT: str=None, GE: str=None, LE: str=None, NE: str=None, Prefix: str=None, SortOrder: str=None, NextToken: str=None, Limit: int=None) -> DescribeBatchPredictionsOutput:
        pass

    def describe_data_sources(self, FilterVariable: str=None, EQ: str=None, GT: str=None, LT: str=None, GE: str=None, LE: str=None, NE: str=None, Prefix: str=None, SortOrder: str=None, NextToken: str=None, Limit: int=None) -> DescribeDataSourcesOutput:
        pass

    def describe_evaluations(self, FilterVariable: str=None, EQ: str=None, GT: str=None, LT: str=None, GE: str=None, LE: str=None, NE: str=None, Prefix: str=None, SortOrder: str=None, NextToken: str=None, Limit: int=None) -> DescribeEvaluationsOutput:
        pass

    def describe_ml_models(self, FilterVariable: str=None, EQ: str=None, GT: str=None, LT: str=None, GE: str=None, LE: str=None, NE: str=None, Prefix: str=None, SortOrder: str=None, NextToken: str=None, Limit: int=None) -> DescribeMLModelsOutput:
        pass

    def describe_tags(self, ResourceType: str, ResourceId: str) -> DescribeTagsOutput:
        pass

    def get_batch_prediction(self, BatchPredictionId: str) -> GetBatchPredictionOutput:
        pass

    def get_data_source(self, DataSourceId: str, Verbose: Verbose=None) -> GetDataSourceOutput:
        pass

    def get_evaluation(self, EvaluationId: str) -> GetEvaluationOutput:
        pass

    def get_ml_model(self, MLModelId: str, Verbose: Verbose=None) -> GetMLModelOutput:
        pass

    def predict(self, PredictEndpoint: str, Record: Record, MLModelId: str) -> PredictOutput:
        pass

    def update_batch_prediction(self, BatchPredictionName: str, BatchPredictionId: str) -> UpdateBatchPredictionOutput:
        pass

    def update_data_source(self, DataSourceName: str, DataSourceId: str) -> UpdateDataSourceOutput:
        pass

    def update_evaluation(self, EvaluationName: str, EvaluationId: str) -> UpdateEvaluationOutput:
        pass

    def update_ml_model(self, MLModelId: str, MLModelName: str=None, ScoreThreshold: ScoreThreshold=None) -> UpdateMLModelOutput:
        pass


class Macie(BaseClient):
    class AssociateMemberAccountRequest(Mapping):
        pass

    class AssociateS3ResourcesRequest(Mapping):
        pass

    class AssociateS3ResourcesResult(Mapping):
        pass

    class S3ResourceClassification(Mapping):
        pass

    class DisassociateMemberAccountRequest(Mapping):
        pass

    class DisassociateS3ResourcesRequest(Mapping):
        pass

    class DisassociateS3ResourcesResult(Mapping):
        pass

    class S3Resource(Mapping):
        pass

    class ListMemberAccountsRequest(Mapping):
        pass

    class ListMemberAccountsResult(Mapping):
        pass

    class ListS3ResourcesRequest(Mapping):
        pass

    class ListS3ResourcesResult(Mapping):
        pass

    class UpdateS3ResourcesRequest(Mapping):
        pass

    class UpdateS3ResourcesResult(Mapping):
        pass

    class S3ResourceClassificationUpdate(Mapping):
        pass

    def associate_member_account(self, memberAccountId: str):
        pass

    def associate_s3_resources(self, s3Resources: List[S3ResourceClassification], memberAccountId: str=None) -> AssociateS3ResourcesResult:
        pass

    def disassociate_member_account(self, memberAccountId: str):
        pass

    def disassociate_s3_resources(self, associatedS3Resources: List[S3Resource], memberAccountId: str=None) -> DisassociateS3ResourcesResult:
        pass

    def list_member_accounts(self, nextToken: str=None, maxResults: int=None) -> ListMemberAccountsResult:
        pass

    def list_s3_resources(self, memberAccountId: str=None, nextToken: str=None, maxResults: int=None) -> ListS3ResourcesResult:
        pass

    def update_s3_resources(self, s3ResourcesUpdate: List[S3ResourceClassificationUpdate], memberAccountId: str=None) -> UpdateS3ResourcesResult:
        pass


class MarketplaceEntitlementService(BaseClient):
    class GetEntitlementsRequest(Mapping):
        pass

    class GetEntitlementsResult(Mapping):
        pass

    class GetEntitlementFilters(object):
        pass

    def get_entitlements(self, ProductCode: str, Filter: GetEntitlementFilters=None, NextToken: str=None, MaxResults: int=None) -> GetEntitlementsResult:
        pass


class MarketplaceCommerceAnalytics(BaseClient):
    class GenerateDataSetRequest(Mapping):
        pass

    class GenerateDataSetResult(Mapping):
        pass

    class DataSetPublicationDate(object):
        pass

    class CustomerDefinedValues(object):
        pass

    class StartSupportDataExportRequest(Mapping):
        pass

    class StartSupportDataExportResult(Mapping):
        pass

    class FromDate(object):
        pass

    def generate_data_set(self, snsTopicArn: str, destinationS3BucketName: str, roleNameArn: str, dataSetPublicationDate: DataSetPublicationDate, dataSetType: str, destinationS3Prefix: str=None, customerDefinedValues: CustomerDefinedValues=None) -> GenerateDataSetResult:
        pass

    def start_support_data_export(self, snsTopicArn: str, destinationS3BucketName: str, roleNameArn: str, fromDate: FromDate, dataSetType: str, destinationS3Prefix: str=None, customerDefinedValues: CustomerDefinedValues=None) -> StartSupportDataExportResult:
        pass


class MediaConnect(BaseClient):
    class AddFlowOutputsRequest(Mapping):
        pass

    class AddFlowOutputsResponse(Mapping):
        pass

    class AddOutputRequest(Mapping):
        pass

    class CreateFlowRequest(Mapping):
        pass

    class CreateFlowResponse(Mapping):
        pass

    class GrantEntitlementRequest(Mapping):
        pass

    class SetSourceRequest(Mapping):
        pass

    class DeleteFlowRequest(Mapping):
        pass

    class DeleteFlowResponse(Mapping):
        pass

    class DescribeFlowRequest(Mapping):
        pass

    class DescribeFlowResponse(Mapping):
        pass

    class GrantFlowEntitlementsRequest(Mapping):
        pass

    class GrantFlowEntitlementsResponse(Mapping):
        pass

    class ListEntitlementsRequest(Mapping):
        pass

    class ListEntitlementsResponse(Mapping):
        pass

    class ListFlowsRequest(Mapping):
        pass

    class ListFlowsResponse(Mapping):
        pass

    class ListTagsForResourceRequest(Mapping):
        pass

    class ListTagsForResourceResponse(Mapping):
        pass

    class RemoveFlowOutputRequest(Mapping):
        pass

    class RemoveFlowOutputResponse(Mapping):
        pass

    class RevokeFlowEntitlementRequest(Mapping):
        pass

    class RevokeFlowEntitlementResponse(Mapping):
        pass

    class StartFlowRequest(Mapping):
        pass

    class StartFlowResponse(Mapping):
        pass

    class StopFlowRequest(Mapping):
        pass

    class StopFlowResponse(Mapping):
        pass

    class TagResourceRequest(Mapping):
        pass

    class __mapOf__string(object):
        pass

    class UntagResourceRequest(Mapping):
        pass

    class __string(object):
        pass

    class UpdateFlowEntitlementRequest(Mapping):
        pass

    class UpdateFlowEntitlementResponse(Mapping):
        pass

    class UpdateEncryption(Mapping):
        pass

    class UpdateFlowOutputRequest(Mapping):
        pass

    class UpdateFlowOutputResponse(Mapping):
        pass

    class UpdateFlowSourceRequest(Mapping):
        pass

    class UpdateFlowSourceResponse(Mapping):
        pass

    def add_flow_outputs(self, Outputs: List[AddOutputRequest], FlowArn: str) -> AddFlowOutputsResponse:
        pass

    def create_flow(self, Source: SetSourceRequest, Name: str, AvailabilityZone: str=None, Entitlements: List[GrantEntitlementRequest]=None, Outputs: List[AddOutputRequest]=None) -> CreateFlowResponse:
        pass

    def delete_flow(self, FlowArn: str) -> DeleteFlowResponse:
        pass

    def describe_flow(self, FlowArn: str) -> DescribeFlowResponse:
        pass

    def grant_flow_entitlements(self, FlowArn: str, Entitlements: List[GrantEntitlementRequest]) -> GrantFlowEntitlementsResponse:
        pass

    def list_entitlements(self, MaxResults: int=None, NextToken: str=None) -> ListEntitlementsResponse:
        pass

    def list_flows(self, MaxResults: int=None, NextToken: str=None) -> ListFlowsResponse:
        pass

    def list_tags_for_resource(self, ResourceArn: str) -> ListTagsForResourceResponse:
        pass

    def remove_flow_output(self, OutputArn: str, FlowArn: str) -> RemoveFlowOutputResponse:
        pass

    def revoke_flow_entitlement(self, FlowArn: str, EntitlementArn: str) -> RevokeFlowEntitlementResponse:
        pass

    def start_flow(self, FlowArn: str) -> StartFlowResponse:
        pass

    def stop_flow(self, FlowArn: str) -> StopFlowResponse:
        pass

    def tag_resource(self, Tags: __mapOf__string, ResourceArn: str):
        pass

    def untag_resource(self, TagKeys: List[__string], ResourceArn: str):
        pass

    def update_flow_entitlement(self, FlowArn: str, EntitlementArn: str, Description: str=None, Encryption: UpdateEncryption=None, Subscribers: List[__string]=None) -> UpdateFlowEntitlementResponse:
        pass

    def update_flow_output(self, OutputArn: str, FlowArn: str, Description: str=None, Destination: str=None, Encryption: UpdateEncryption=None, MaxLatency: int=None, Port: int=None, Protocol: str=None, SmoothingLatency: int=None, StreamId: str=None) -> UpdateFlowOutputResponse:
        pass

    def update_flow_source(self, SourceArn: str, FlowArn: str, Decryption: UpdateEncryption=None, Description: str=None, EntitlementArn: str=None, IngestPort: int=None, MaxBitrate: int=None, MaxLatency: int=None, Protocol: str=None, StreamId: str=None, WhitelistCidr: str=None) -> UpdateFlowSourceResponse:
        pass


class MediaConvert(BaseClient):
    class AssociateCertificateRequest(Mapping):
        pass

    class AssociateCertificateResponse(Mapping):
        pass

    class CancelJobRequest(Mapping):
        pass

    class CancelJobResponse(Mapping):
        pass

    class CreateJobRequest(Mapping):
        pass

    class CreateJobResponse(Mapping):
        pass

    class AccelerationSettings(Mapping):
        pass

    class JobSettings(Mapping):
        pass

    class __mapOf__string(object):
        pass

    class CreateJobTemplateRequest(Mapping):
        pass

    class CreateJobTemplateResponse(Mapping):
        pass

    class JobTemplateSettings(Mapping):
        pass

    class CreatePresetRequest(Mapping):
        pass

    class CreatePresetResponse(Mapping):
        pass

    class PresetSettings(Mapping):
        pass

    class CreateQueueRequest(Mapping):
        pass

    class CreateQueueResponse(Mapping):
        pass

    class ReservationPlanSettings(Mapping):
        pass

    class DeleteJobTemplateRequest(Mapping):
        pass

    class DeleteJobTemplateResponse(Mapping):
        pass

    class DeletePresetRequest(Mapping):
        pass

    class DeletePresetResponse(Mapping):
        pass

    class DeleteQueueRequest(Mapping):
        pass

    class DeleteQueueResponse(Mapping):
        pass

    class DescribeEndpointsRequest(Mapping):
        pass

    class DescribeEndpointsResponse(Mapping):
        pass

    class DisassociateCertificateRequest(Mapping):
        pass

    class DisassociateCertificateResponse(Mapping):
        pass

    class GetJobRequest(Mapping):
        pass

    class GetJobResponse(Mapping):
        pass

    class GetJobTemplateRequest(Mapping):
        pass

    class GetJobTemplateResponse(Mapping):
        pass

    class GetPresetRequest(Mapping):
        pass

    class GetPresetResponse(Mapping):
        pass

    class GetQueueRequest(Mapping):
        pass

    class GetQueueResponse(Mapping):
        pass

    class ListJobTemplatesRequest(Mapping):
        pass

    class ListJobTemplatesResponse(Mapping):
        pass

    class ListJobsRequest(Mapping):
        pass

    class ListJobsResponse(Mapping):
        pass

    class ListPresetsRequest(Mapping):
        pass

    class ListPresetsResponse(Mapping):
        pass

    class ListQueuesRequest(Mapping):
        pass

    class ListQueuesResponse(Mapping):
        pass

    class ListTagsForResourceRequest(Mapping):
        pass

    class ListTagsForResourceResponse(Mapping):
        pass

    class TagResourceRequest(Mapping):
        pass

    class TagResourceResponse(Mapping):
        pass

    class UntagResourceRequest(Mapping):
        pass

    class UntagResourceResponse(Mapping):
        pass

    class __string(object):
        pass

    class UpdateJobTemplateRequest(Mapping):
        pass

    class UpdateJobTemplateResponse(Mapping):
        pass

    class UpdatePresetRequest(Mapping):
        pass

    class UpdatePresetResponse(Mapping):
        pass

    class UpdateQueueRequest(Mapping):
        pass

    class UpdateQueueResponse(Mapping):
        pass

    def associate_certificate(self, Arn: str) -> AssociateCertificateResponse:
        pass

    def cancel_job(self, Id: str) -> CancelJobResponse:
        pass

    def create_job(self, Settings: JobSettings, Role: str, AccelerationSettings: AccelerationSettings=None, BillingTagsSource: str=None, ClientRequestToken: str=None, JobTemplate: str=None, Queue: str=None, UserMetadata: __mapOf__string=None) -> CreateJobResponse:
        pass

    def create_job_template(self, Settings: JobTemplateSettings, Name: str, AccelerationSettings: AccelerationSettings=None, Category: str=None, Description: str=None, Queue: str=None, Tags: __mapOf__string=None) -> CreateJobTemplateResponse:
        pass

    def create_preset(self, Settings: PresetSettings, Name: str, Category: str=None, Description: str=None, Tags: __mapOf__string=None) -> CreatePresetResponse:
        pass

    def create_queue(self, Name: str, Description: str=None, PricingPlan: str=None, ReservationPlanSettings: ReservationPlanSettings=None, Tags: __mapOf__string=None) -> CreateQueueResponse:
        pass

    def delete_job_template(self, Name: str) -> DeleteJobTemplateResponse:
        pass

    def delete_preset(self, Name: str) -> DeletePresetResponse:
        pass

    def delete_queue(self, Name: str) -> DeleteQueueResponse:
        pass

    def describe_endpoints(self, MaxResults: int=None, Mode: str=None, NextToken: str=None) -> DescribeEndpointsResponse:
        pass

    def disassociate_certificate(self, Arn: str) -> DisassociateCertificateResponse:
        pass

    def get_job(self, Id: str) -> GetJobResponse:
        pass

    def get_job_template(self, Name: str) -> GetJobTemplateResponse:
        pass

    def get_preset(self, Name: str) -> GetPresetResponse:
        pass

    def get_queue(self, Name: str) -> GetQueueResponse:
        pass

    def list_job_templates(self, Category: str=None, ListBy: str=None, MaxResults: int=None, NextToken: str=None, Order: str=None) -> ListJobTemplatesResponse:
        pass

    def list_jobs(self, MaxResults: int=None, NextToken: str=None, Order: str=None, Queue: str=None, Status: str=None) -> ListJobsResponse:
        pass

    def list_presets(self, Category: str=None, ListBy: str=None, MaxResults: int=None, NextToken: str=None, Order: str=None) -> ListPresetsResponse:
        pass

    def list_queues(self, ListBy: str=None, MaxResults: int=None, NextToken: str=None, Order: str=None) -> ListQueuesResponse:
        pass

    def list_tags_for_resource(self, Arn: str) -> ListTagsForResourceResponse:
        pass

    def tag_resource(self, Tags: __mapOf__string, Arn: str) -> TagResourceResponse:
        pass

    def untag_resource(self, Arn: str, TagKeys: List[__string]=None) -> UntagResourceResponse:
        pass

    def update_job_template(self, Name: str, AccelerationSettings: AccelerationSettings=None, Category: str=None, Description: str=None, Queue: str=None, Settings: JobTemplateSettings=None) -> UpdateJobTemplateResponse:
        pass

    def update_preset(self, Name: str, Category: str=None, Description: str=None, Settings: PresetSettings=None) -> UpdatePresetResponse:
        pass

    def update_queue(self, Name: str, Description: str=None, ReservationPlanSettings: ReservationPlanSettings=None, Status: str=None) -> UpdateQueueResponse:
        pass


class MediaLive(BaseClient):
    class BatchUpdateScheduleRequest(Mapping):
        pass

    class BatchUpdateScheduleResponse(Mapping):
        pass

    class BatchScheduleActionCreateRequest(Mapping):
        pass

    class BatchScheduleActionDeleteRequest(Mapping):
        pass

    class CreateChannelRequest(Mapping):
        pass

    class CreateChannelResponse(Mapping):
        pass

    class OutputDestination(Mapping):
        pass

    class EncoderSettings(Mapping):
        pass

    class InputAttachment(Mapping):
        pass

    class InputSpecification(Mapping):
        pass

    class CreateInputRequest(Mapping):
        pass

    class CreateInputResponse(Mapping):
        pass

    class InputDestinationRequest(Mapping):
        pass

    class __string(object):
        pass

    class MediaConnectFlowRequest(Mapping):
        pass

    class InputSourceRequest(Mapping):
        pass

    class CreateInputSecurityGroupRequest(Mapping):
        pass

    class CreateInputSecurityGroupResponse(Mapping):
        pass

    class InputWhitelistRuleCidr(Mapping):
        pass

    class DeleteChannelRequest(Mapping):
        pass

    class DeleteChannelResponse(Mapping):
        pass

    class DeleteInputRequest(Mapping):
        pass

    class DeleteInputResponse(Mapping):
        pass

    class DeleteInputSecurityGroupRequest(Mapping):
        pass

    class DeleteInputSecurityGroupResponse(Mapping):
        pass

    class DeleteReservationRequest(Mapping):
        pass

    class DeleteReservationResponse(Mapping):
        pass

    class DescribeChannelRequest(Mapping):
        pass

    class DescribeChannelResponse(Mapping):
        pass

    class DescribeInputRequest(Mapping):
        pass

    class DescribeInputResponse(Mapping):
        pass

    class DescribeInputSecurityGroupRequest(Mapping):
        pass

    class DescribeInputSecurityGroupResponse(Mapping):
        pass

    class DescribeOfferingRequest(Mapping):
        pass

    class DescribeOfferingResponse(Mapping):
        pass

    class DescribeReservationRequest(Mapping):
        pass

    class DescribeReservationResponse(Mapping):
        pass

    class DescribeScheduleRequest(Mapping):
        pass

    class DescribeScheduleResponse(Mapping):
        pass

    class ListChannelsRequest(Mapping):
        pass

    class ListChannelsResponse(Mapping):
        pass

    class ListInputSecurityGroupsRequest(Mapping):
        pass

    class ListInputSecurityGroupsResponse(Mapping):
        pass

    class ListInputsRequest(Mapping):
        pass

    class ListInputsResponse(Mapping):
        pass

    class ListOfferingsRequest(Mapping):
        pass

    class ListOfferingsResponse(Mapping):
        pass

    class ListReservationsRequest(Mapping):
        pass

    class ListReservationsResponse(Mapping):
        pass

    class PurchaseOfferingRequest(Mapping):
        pass

    class PurchaseOfferingResponse(Mapping):
        pass

    class StartChannelRequest(Mapping):
        pass

    class StartChannelResponse(Mapping):
        pass

    class StopChannelRequest(Mapping):
        pass

    class StopChannelResponse(Mapping):
        pass

    class UpdateChannelRequest(Mapping):
        pass

    class UpdateChannelResponse(Mapping):
        pass

    class UpdateInputRequest(Mapping):
        pass

    class UpdateInputResponse(Mapping):
        pass

    class UpdateInputSecurityGroupRequest(Mapping):
        pass

    class UpdateInputSecurityGroupResponse(Mapping):
        pass

    def batch_update_schedule(self, ChannelId: str, Creates: BatchScheduleActionCreateRequest=None, Deletes: BatchScheduleActionDeleteRequest=None) -> BatchUpdateScheduleResponse:
        pass

    def create_channel(self, Destinations: List[OutputDestination]=None, EncoderSettings: EncoderSettings=None, InputAttachments: List[InputAttachment]=None, InputSpecification: InputSpecification=None, LogLevel: str=None, Name: str=None, RequestId: str=None, Reserved: str=None, RoleArn: str=None) -> CreateChannelResponse:
        pass

    def create_input(self, Destinations: List[InputDestinationRequest]=None, InputSecurityGroups: List[__string]=None, MediaConnectFlows: List[MediaConnectFlowRequest]=None, Name: str=None, RequestId: str=None, RoleArn: str=None, Sources: List[InputSourceRequest]=None, Type: str=None) -> CreateInputResponse:
        pass

    def create_input_security_group(self, WhitelistRules: List[InputWhitelistRuleCidr]=None) -> CreateInputSecurityGroupResponse:
        pass

    def delete_channel(self, ChannelId: str) -> DeleteChannelResponse:
        pass

    def delete_input(self, InputId: str) -> DeleteInputResponse:
        pass

    def delete_input_security_group(self, InputSecurityGroupId: str) -> DeleteInputSecurityGroupResponse:
        pass

    def delete_reservation(self, ReservationId: str) -> DeleteReservationResponse:
        pass

    def describe_channel(self, ChannelId: str) -> DescribeChannelResponse:
        pass

    def describe_input(self, InputId: str) -> DescribeInputResponse:
        pass

    def describe_input_security_group(self, InputSecurityGroupId: str) -> DescribeInputSecurityGroupResponse:
        pass

    def describe_offering(self, OfferingId: str) -> DescribeOfferingResponse:
        pass

    def describe_reservation(self, ReservationId: str) -> DescribeReservationResponse:
        pass

    def describe_schedule(self, ChannelId: str, MaxResults: int=None, NextToken: str=None) -> DescribeScheduleResponse:
        pass

    def list_channels(self, MaxResults: int=None, NextToken: str=None) -> ListChannelsResponse:
        pass

    def list_input_security_groups(self, MaxResults: int=None, NextToken: str=None) -> ListInputSecurityGroupsResponse:
        pass

    def list_inputs(self, MaxResults: int=None, NextToken: str=None) -> ListInputsResponse:
        pass

    def list_offerings(self, ChannelConfiguration: str=None, Codec: str=None, MaxResults: int=None, MaximumBitrate: str=None, MaximumFramerate: str=None, NextToken: str=None, Resolution: str=None, ResourceType: str=None, SpecialFeature: str=None, VideoQuality: str=None) -> ListOfferingsResponse:
        pass

    def list_reservations(self, Codec: str=None, MaxResults: int=None, MaximumBitrate: str=None, MaximumFramerate: str=None, NextToken: str=None, Resolution: str=None, ResourceType: str=None, SpecialFeature: str=None, VideoQuality: str=None) -> ListReservationsResponse:
        pass

    def purchase_offering(self, OfferingId: str, Count: int, Name: str=None, RequestId: str=None, Start: str=None) -> PurchaseOfferingResponse:
        pass

    def start_channel(self, ChannelId: str) -> StartChannelResponse:
        pass

    def stop_channel(self, ChannelId: str) -> StopChannelResponse:
        pass

    def update_channel(self, ChannelId: str, Destinations: List[OutputDestination]=None, EncoderSettings: EncoderSettings=None, InputAttachments: List[InputAttachment]=None, InputSpecification: InputSpecification=None, LogLevel: str=None, Name: str=None, RoleArn: str=None) -> UpdateChannelResponse:
        pass

    def update_input(self, InputId: str, Destinations: List[InputDestinationRequest]=None, InputSecurityGroups: List[__string]=None, MediaConnectFlows: List[MediaConnectFlowRequest]=None, Name: str=None, RoleArn: str=None, Sources: List[InputSourceRequest]=None) -> UpdateInputResponse:
        pass

    def update_input_security_group(self, InputSecurityGroupId: str, WhitelistRules: List[InputWhitelistRuleCidr]=None) -> UpdateInputSecurityGroupResponse:
        pass


class MediaPackage(BaseClient):
    class CreateChannelRequest(Mapping):
        pass

    class CreateChannelResponse(Mapping):
        pass

    class CreateOriginEndpointRequest(Mapping):
        pass

    class CreateOriginEndpointResponse(Mapping):
        pass

    class CmafPackageCreateOrUpdateParameters(Mapping):
        pass

    class DashPackage(Mapping):
        pass

    class HlsPackage(Mapping):
        pass

    class MssPackage(Mapping):
        pass

    class __string(object):
        pass

    class DeleteChannelRequest(Mapping):
        pass

    class DeleteChannelResponse(Mapping):
        pass

    class DeleteOriginEndpointRequest(Mapping):
        pass

    class DeleteOriginEndpointResponse(Mapping):
        pass

    class DescribeChannelRequest(Mapping):
        pass

    class DescribeChannelResponse(Mapping):
        pass

    class DescribeOriginEndpointRequest(Mapping):
        pass

    class DescribeOriginEndpointResponse(Mapping):
        pass

    class ListChannelsRequest(Mapping):
        pass

    class ListChannelsResponse(Mapping):
        pass

    class ListOriginEndpointsRequest(Mapping):
        pass

    class ListOriginEndpointsResponse(Mapping):
        pass

    class RotateChannelCredentialsRequest(Mapping):
        pass

    class RotateChannelCredentialsResponse(Mapping):
        pass

    class RotateIngestEndpointCredentialsRequest(Mapping):
        pass

    class RotateIngestEndpointCredentialsResponse(Mapping):
        pass

    class UpdateChannelRequest(Mapping):
        pass

    class UpdateChannelResponse(Mapping):
        pass

    class UpdateOriginEndpointRequest(Mapping):
        pass

    class UpdateOriginEndpointResponse(Mapping):
        pass

    def create_channel(self, Id: str, Description: str=None) -> CreateChannelResponse:
        pass

    def create_origin_endpoint(self, Id: str, ChannelId: str, CmafPackage: CmafPackageCreateOrUpdateParameters=None, DashPackage: DashPackage=None, Description: str=None, HlsPackage: HlsPackage=None, ManifestName: str=None, MssPackage: MssPackage=None, StartoverWindowSeconds: int=None, TimeDelaySeconds: int=None, Whitelist: List[__string]=None) -> CreateOriginEndpointResponse:
        pass

    def delete_channel(self, Id: str) -> DeleteChannelResponse:
        pass

    def delete_origin_endpoint(self, Id: str) -> DeleteOriginEndpointResponse:
        pass

    def describe_channel(self, Id: str) -> DescribeChannelResponse:
        pass

    def describe_origin_endpoint(self, Id: str) -> DescribeOriginEndpointResponse:
        pass

    def list_channels(self, MaxResults: int=None, NextToken: str=None) -> ListChannelsResponse:
        pass

    def list_origin_endpoints(self, ChannelId: str=None, MaxResults: int=None, NextToken: str=None) -> ListOriginEndpointsResponse:
        pass

    def rotate_channel_credentials(self, Id: str) -> RotateChannelCredentialsResponse:
        pass

    def rotate_ingest_endpoint_credentials(self, IngestEndpointId: str, Id: str) -> RotateIngestEndpointCredentialsResponse:
        pass

    def update_channel(self, Id: str, Description: str=None) -> UpdateChannelResponse:
        pass

    def update_origin_endpoint(self, Id: str, CmafPackage: CmafPackageCreateOrUpdateParameters=None, DashPackage: DashPackage=None, Description: str=None, HlsPackage: HlsPackage=None, ManifestName: str=None, MssPackage: MssPackage=None, StartoverWindowSeconds: int=None, TimeDelaySeconds: int=None, Whitelist: List[__string]=None) -> UpdateOriginEndpointResponse:
        pass


class MediaStore(BaseClient):
    class CreateContainerInput(Mapping):
        pass

    class CreateContainerOutput(Mapping):
        pass

    class DeleteContainerInput(Mapping):
        pass

    class DeleteContainerOutput(Mapping):
        pass

    class DeleteContainerPolicyInput(Mapping):
        pass

    class DeleteContainerPolicyOutput(Mapping):
        pass

    class DeleteCorsPolicyInput(Mapping):
        pass

    class DeleteCorsPolicyOutput(Mapping):
        pass

    class DeleteLifecyclePolicyInput(Mapping):
        pass

    class DeleteLifecyclePolicyOutput(Mapping):
        pass

    class DescribeContainerInput(Mapping):
        pass

    class DescribeContainerOutput(Mapping):
        pass

    class GetContainerPolicyInput(Mapping):
        pass

    class GetContainerPolicyOutput(Mapping):
        pass

    class GetCorsPolicyInput(Mapping):
        pass

    class GetCorsPolicyOutput(Mapping):
        pass

    class GetLifecyclePolicyInput(Mapping):
        pass

    class GetLifecyclePolicyOutput(Mapping):
        pass

    class ListContainersInput(Mapping):
        pass

    class ListContainersOutput(Mapping):
        pass

    class PutContainerPolicyInput(Mapping):
        pass

    class PutContainerPolicyOutput(Mapping):
        pass

    class PutCorsPolicyInput(Mapping):
        pass

    class PutCorsPolicyOutput(Mapping):
        pass

    class CorsRule(Mapping):
        pass

    class PutLifecyclePolicyInput(Mapping):
        pass

    class PutLifecyclePolicyOutput(Mapping):
        pass

    def create_container(self, ContainerName: str) -> CreateContainerOutput:
        pass

    def delete_container(self, ContainerName: str) -> DeleteContainerOutput:
        pass

    def delete_container_policy(self, ContainerName: str) -> DeleteContainerPolicyOutput:
        pass

    def delete_cors_policy(self, ContainerName: str) -> DeleteCorsPolicyOutput:
        pass

    def delete_lifecycle_policy(self, ContainerName: str) -> DeleteLifecyclePolicyOutput:
        pass

    def describe_container(self, ContainerName: str=None) -> DescribeContainerOutput:
        pass

    def get_container_policy(self, ContainerName: str) -> GetContainerPolicyOutput:
        pass

    def get_cors_policy(self, ContainerName: str) -> GetCorsPolicyOutput:
        pass

    def get_lifecycle_policy(self, ContainerName: str) -> GetLifecyclePolicyOutput:
        pass

    def list_containers(self, NextToken: str=None, MaxResults: int=None) -> ListContainersOutput:
        pass

    def put_container_policy(self, Policy: str, ContainerName: str) -> PutContainerPolicyOutput:
        pass

    def put_cors_policy(self, CorsPolicy: List[CorsRule], ContainerName: str) -> PutCorsPolicyOutput:
        pass

    def put_lifecycle_policy(self, LifecyclePolicy: str, ContainerName: str) -> PutLifecyclePolicyOutput:
        pass


class MediaStoreData(BaseClient):
    class DeleteObjectRequest(Mapping):
        pass

    class DeleteObjectResponse(Mapping):
        pass

    class DescribeObjectRequest(Mapping):
        pass

    class DescribeObjectResponse(Mapping):
        pass

    class GetObjectRequest(Mapping):
        pass

    class GetObjectResponse(Mapping):
        pass

    class ListItemsRequest(Mapping):
        pass

    class ListItemsResponse(Mapping):
        pass

    class PutObjectRequest(Mapping):
        pass

    class PutObjectResponse(Mapping):
        pass

    class PayloadBlob(object):
        pass

    def delete_object(self, Path: str) -> DeleteObjectResponse:
        pass

    def describe_object(self, Path: str) -> DescribeObjectResponse:
        pass

    def get_object(self, Path: str, Range: str=None) -> GetObjectResponse:
        pass

    def list_items(self, Path: str=None, MaxResults: int=None, NextToken: str=None) -> ListItemsResponse:
        pass

    def put_object(self, Path: str, Body: PayloadBlob, ContentType: str=None, CacheControl: str=None, StorageClass: str=None) -> PutObjectResponse:
        pass


class MediaTailor(BaseClient):
    class DeletePlaybackConfigurationRequest(Mapping):
        pass

    class DeletePlaybackConfigurationResponse(Mapping):
        pass

    class GetPlaybackConfigurationRequest(Mapping):
        pass

    class GetPlaybackConfigurationResponse(Mapping):
        pass

    class ListPlaybackConfigurationsRequest(Mapping):
        pass

    class ListPlaybackConfigurationsResponse(Mapping):
        pass

    class PutPlaybackConfigurationRequest(Mapping):
        pass

    class PutPlaybackConfigurationResponse(Mapping):
        pass

    class CdnConfiguration(Mapping):
        pass

    class DashConfigurationForPut(Mapping):
        pass

    def delete_playback_configuration(self, Name: str) -> DeletePlaybackConfigurationResponse:
        pass

    def get_playback_configuration(self, Name: str) -> GetPlaybackConfigurationResponse:
        pass

    def list_playback_configurations(self, MaxResults: int=None, NextToken: str=None) -> ListPlaybackConfigurationsResponse:
        pass

    def put_playback_configuration(self, AdDecisionServerUrl: str=None, CdnConfiguration: CdnConfiguration=None, DashConfiguration: DashConfigurationForPut=None, Name: str=None, SlateAdUrl: str=None, TranscodeProfileName: str=None, VideoContentSourceUrl: str=None) -> PutPlaybackConfigurationResponse:
        pass


class MarketplaceMetering(BaseClient):
    class BatchMeterUsageRequest(Mapping):
        pass

    class BatchMeterUsageResult(Mapping):
        pass

    class UsageRecord(Mapping):
        pass

    class MeterUsageRequest(Mapping):
        pass

    class MeterUsageResult(Mapping):
        pass

    class Timestamp(object):
        pass

    class Boolean(object):
        pass

    class RegisterUsageRequest(Mapping):
        pass

    class RegisterUsageResult(Mapping):
        pass

    class ResolveCustomerRequest(Mapping):
        pass

    class ResolveCustomerResult(Mapping):
        pass

    def batch_meter_usage(self, ProductCode: str, UsageRecords: List[UsageRecord]) -> BatchMeterUsageResult:
        pass

    def meter_usage(self, DryRun: Boolean, UsageQuantity: int, UsageDimension: str, Timestamp: Timestamp, ProductCode: str) -> MeterUsageResult:
        pass

    def register_usage(self, PublicKeyVersion: int, ProductCode: str, Nonce: str=None) -> RegisterUsageResult:
        pass

    def resolve_customer(self, RegistrationToken: str) -> ResolveCustomerResult:
        pass


class MigrationHub(BaseClient):
    class AssociateCreatedArtifactRequest(Mapping):
        pass

    class AssociateCreatedArtifactResult(Mapping):
        pass

    class CreatedArtifact(Mapping):
        pass

    class DryRun(object):
        pass

    class AssociateDiscoveredResourceRequest(Mapping):
        pass

    class AssociateDiscoveredResourceResult(Mapping):
        pass

    class DiscoveredResource(Mapping):
        pass

    class CreateProgressUpdateStreamRequest(Mapping):
        pass

    class CreateProgressUpdateStreamResult(Mapping):
        pass

    class DeleteProgressUpdateStreamRequest(Mapping):
        pass

    class DeleteProgressUpdateStreamResult(Mapping):
        pass

    class DescribeApplicationStateRequest(Mapping):
        pass

    class DescribeApplicationStateResult(Mapping):
        pass

    class DescribeMigrationTaskRequest(Mapping):
        pass

    class DescribeMigrationTaskResult(Mapping):
        pass

    class DisassociateCreatedArtifactRequest(Mapping):
        pass

    class DisassociateCreatedArtifactResult(Mapping):
        pass

    class DisassociateDiscoveredResourceRequest(Mapping):
        pass

    class DisassociateDiscoveredResourceResult(Mapping):
        pass

    class ImportMigrationTaskRequest(Mapping):
        pass

    class ImportMigrationTaskResult(Mapping):
        pass

    class ListCreatedArtifactsRequest(Mapping):
        pass

    class ListCreatedArtifactsResult(Mapping):
        pass

    class ListDiscoveredResourcesRequest(Mapping):
        pass

    class ListDiscoveredResourcesResult(Mapping):
        pass

    class ListMigrationTasksRequest(Mapping):
        pass

    class ListMigrationTasksResult(Mapping):
        pass

    class ListProgressUpdateStreamsRequest(Mapping):
        pass

    class ListProgressUpdateStreamsResult(Mapping):
        pass

    class NotifyApplicationStateRequest(Mapping):
        pass

    class NotifyApplicationStateResult(Mapping):
        pass

    class NotifyMigrationTaskStateRequest(Mapping):
        pass

    class NotifyMigrationTaskStateResult(Mapping):
        pass

    class Task(Mapping):
        pass

    class UpdateDateTime(object):
        pass

    class PutResourceAttributesRequest(Mapping):
        pass

    class PutResourceAttributesResult(Mapping):
        pass

    class ResourceAttribute(Mapping):
        pass

    def associate_created_artifact(self, CreatedArtifact: CreatedArtifact, MigrationTaskName: str, ProgressUpdateStream: str, DryRun: DryRun=None) -> AssociateCreatedArtifactResult:
        pass

    def associate_discovered_resource(self, DiscoveredResource: DiscoveredResource, MigrationTaskName: str, ProgressUpdateStream: str, DryRun: DryRun=None) -> AssociateDiscoveredResourceResult:
        pass

    def create_progress_update_stream(self, ProgressUpdateStreamName: str, DryRun: DryRun=None) -> CreateProgressUpdateStreamResult:
        pass

    def delete_progress_update_stream(self, ProgressUpdateStreamName: str, DryRun: DryRun=None) -> DeleteProgressUpdateStreamResult:
        pass

    def describe_application_state(self, ApplicationId: str) -> DescribeApplicationStateResult:
        pass

    def describe_migration_task(self, MigrationTaskName: str, ProgressUpdateStream: str) -> DescribeMigrationTaskResult:
        pass

    def disassociate_created_artifact(self, CreatedArtifactName: str, MigrationTaskName: str, ProgressUpdateStream: str, DryRun: DryRun=None) -> DisassociateCreatedArtifactResult:
        pass

    def disassociate_discovered_resource(self, ConfigurationId: str, MigrationTaskName: str, ProgressUpdateStream: str, DryRun: DryRun=None) -> DisassociateDiscoveredResourceResult:
        pass

    def import_migration_task(self, MigrationTaskName: str, ProgressUpdateStream: str, DryRun: DryRun=None) -> ImportMigrationTaskResult:
        pass

    def list_created_artifacts(self, MigrationTaskName: str, ProgressUpdateStream: str, NextToken: str=None, MaxResults: int=None) -> ListCreatedArtifactsResult:
        pass

    def list_discovered_resources(self, MigrationTaskName: str, ProgressUpdateStream: str, NextToken: str=None, MaxResults: int=None) -> ListDiscoveredResourcesResult:
        pass

    def list_migration_tasks(self, NextToken: str=None, MaxResults: int=None, ResourceName: str=None) -> ListMigrationTasksResult:
        pass

    def list_progress_update_streams(self, NextToken: str=None, MaxResults: int=None) -> ListProgressUpdateStreamsResult:
        pass

    def notify_application_state(self, Status: str, ApplicationId: str, DryRun: DryRun=None) -> NotifyApplicationStateResult:
        pass

    def notify_migration_task_state(self, NextUpdateSeconds: int, UpdateDateTime: UpdateDateTime, Task: Task, MigrationTaskName: str, ProgressUpdateStream: str, DryRun: DryRun=None) -> NotifyMigrationTaskStateResult:
        pass

    def put_resource_attributes(self, ResourceAttributeList: List[ResourceAttribute], MigrationTaskName: str, ProgressUpdateStream: str, DryRun: DryRun=None) -> PutResourceAttributesResult:
        pass


class Mobile(BaseClient):
    class CreateProjectRequest(Mapping):
        pass

    class CreateProjectResult(Mapping):
        pass

    class Contents(object):
        pass

    class DeleteProjectRequest(Mapping):
        pass

    class DeleteProjectResult(Mapping):
        pass

    class DescribeBundleRequest(Mapping):
        pass

    class DescribeBundleResult(Mapping):
        pass

    class DescribeProjectRequest(Mapping):
        pass

    class DescribeProjectResult(Mapping):
        pass

    class Boolean(object):
        pass

    class ExportBundleRequest(Mapping):
        pass

    class ExportBundleResult(Mapping):
        pass

    class ExportProjectRequest(Mapping):
        pass

    class ExportProjectResult(Mapping):
        pass

    class ListBundlesRequest(Mapping):
        pass

    class ListBundlesResult(Mapping):
        pass

    class ListProjectsRequest(Mapping):
        pass

    class ListProjectsResult(Mapping):
        pass

    class UpdateProjectRequest(Mapping):
        pass

    class UpdateProjectResult(Mapping):
        pass

    def create_project(self, name: str=None, region: str=None, contents: Contents=None, snapshotId: str=None) -> CreateProjectResult:
        pass

    def delete_project(self, projectId: str) -> DeleteProjectResult:
        pass

    def describe_bundle(self, bundleId: str) -> DescribeBundleResult:
        pass

    def describe_project(self, projectId: str, syncFromResources: Boolean=None) -> DescribeProjectResult:
        pass

    def export_bundle(self, bundleId: str, projectId: str=None, platform: str=None) -> ExportBundleResult:
        pass

    def export_project(self, projectId: str) -> ExportProjectResult:
        pass

    def list_bundles(self, maxResults: int=None, nextToken: str=None) -> ListBundlesResult:
        pass

    def list_projects(self, maxResults: int=None, nextToken: str=None) -> ListProjectsResult:
        pass

    def update_project(self, projectId: str, contents: Contents=None) -> UpdateProjectResult:
        pass


class MQ(BaseClient):
    class CreateBrokerRequest(Mapping):
        pass

    class CreateBrokerResponse(Mapping):
        pass

    class __boolean(object):
        pass

    class ConfigurationId(Mapping):
        pass

    class Logs(Mapping):
        pass

    class WeeklyStartTime(Mapping):
        pass

    class __string(object):
        pass

    class __mapOf__string(object):
        pass

    class User(Mapping):
        pass

    class CreateConfigurationRequest(Mapping):
        pass

    class CreateConfigurationResponse(Mapping):
        pass

    class CreateTagsRequest(Mapping):
        pass

    class CreateUserRequest(Mapping):
        pass

    class CreateUserResponse(Mapping):
        pass

    class DeleteBrokerRequest(Mapping):
        pass

    class DeleteBrokerResponse(Mapping):
        pass

    class DeleteTagsRequest(Mapping):
        pass

    class DeleteUserRequest(Mapping):
        pass

    class DeleteUserResponse(Mapping):
        pass

    class DescribeBrokerRequest(Mapping):
        pass

    class DescribeBrokerResponse(Mapping):
        pass

    class DescribeConfigurationRequest(Mapping):
        pass

    class DescribeConfigurationResponse(Mapping):
        pass

    class DescribeConfigurationRevisionRequest(Mapping):
        pass

    class DescribeConfigurationRevisionResponse(Mapping):
        pass

    class DescribeUserRequest(Mapping):
        pass

    class DescribeUserResponse(Mapping):
        pass

    class ListBrokersRequest(Mapping):
        pass

    class ListBrokersResponse(Mapping):
        pass

    class ListConfigurationRevisionsRequest(Mapping):
        pass

    class ListConfigurationRevisionsResponse(Mapping):
        pass

    class ListConfigurationsRequest(Mapping):
        pass

    class ListConfigurationsResponse(Mapping):
        pass

    class ListTagsRequest(Mapping):
        pass

    class ListTagsResponse(Mapping):
        pass

    class ListUsersRequest(Mapping):
        pass

    class ListUsersResponse(Mapping):
        pass

    class RebootBrokerRequest(Mapping):
        pass

    class RebootBrokerResponse(Mapping):
        pass

    class UpdateBrokerRequest(Mapping):
        pass

    class UpdateBrokerResponse(Mapping):
        pass

    class UpdateConfigurationRequest(Mapping):
        pass

    class UpdateConfigurationResponse(Mapping):
        pass

    class UpdateUserRequest(Mapping):
        pass

    class UpdateUserResponse(Mapping):
        pass

    def create_broker(self, AutoMinorVersionUpgrade: __boolean=None, BrokerName: str=None, Configuration: ConfigurationId=None, CreatorRequestId: str=None, DeploymentMode: str=None, EngineType: str=None, EngineVersion: str=None, HostInstanceType: str=None, Logs: Logs=None, MaintenanceWindowStartTime: WeeklyStartTime=None, PubliclyAccessible: __boolean=None, SecurityGroups: List[__string]=None, SubnetIds: List[__string]=None, Tags: __mapOf__string=None, Users: List[User]=None) -> CreateBrokerResponse:
        pass

    def create_configuration(self, EngineType: str=None, EngineVersion: str=None, Name: str=None, Tags: __mapOf__string=None) -> CreateConfigurationResponse:
        pass

    def create_tags(self, ResourceArn: str, Tags: __mapOf__string=None):
        pass

    def create_user(self, Username: str, BrokerId: str, ConsoleAccess: __boolean=None, Groups: List[__string]=None, Password: str=None) -> CreateUserResponse:
        pass

    def delete_broker(self, BrokerId: str) -> DeleteBrokerResponse:
        pass

    def delete_tags(self, TagKeys: List[__string], ResourceArn: str):
        pass

    def delete_user(self, Username: str, BrokerId: str) -> DeleteUserResponse:
        pass

    def describe_broker(self, BrokerId: str) -> DescribeBrokerResponse:
        pass

    def describe_configuration(self, ConfigurationId: str) -> DescribeConfigurationResponse:
        pass

    def describe_configuration_revision(self, ConfigurationRevision: str, ConfigurationId: str) -> DescribeConfigurationRevisionResponse:
        pass

    def describe_user(self, Username: str, BrokerId: str) -> DescribeUserResponse:
        pass

    def list_brokers(self, MaxResults: int=None, NextToken: str=None) -> ListBrokersResponse:
        pass

    def list_configuration_revisions(self, ConfigurationId: str, MaxResults: int=None, NextToken: str=None) -> ListConfigurationRevisionsResponse:
        pass

    def list_configurations(self, MaxResults: int=None, NextToken: str=None) -> ListConfigurationsResponse:
        pass

    def list_tags(self, ResourceArn: str) -> ListTagsResponse:
        pass

    def list_users(self, BrokerId: str, MaxResults: int=None, NextToken: str=None) -> ListUsersResponse:
        pass

    def reboot_broker(self, BrokerId: str) -> RebootBrokerResponse:
        pass

    def update_broker(self, BrokerId: str, AutoMinorVersionUpgrade: __boolean=None, Configuration: ConfigurationId=None, EngineVersion: str=None, Logs: Logs=None) -> UpdateBrokerResponse:
        pass

    def update_configuration(self, ConfigurationId: str, Data: str=None, Description: str=None) -> UpdateConfigurationResponse:
        pass

    def update_user(self, Username: str, BrokerId: str, ConsoleAccess: __boolean=None, Groups: List[__string]=None, Password: str=None) -> UpdateUserResponse:
        pass


class MTurk(BaseClient):
    class AcceptQualificationRequestRequest(Mapping):
        pass

    class AcceptQualificationRequestResponse(Mapping):
        pass

    class ApproveAssignmentRequest(Mapping):
        pass

    class ApproveAssignmentResponse(Mapping):
        pass

    class Boolean(object):
        pass

    class AssociateQualificationWithWorkerRequest(Mapping):
        pass

    class AssociateQualificationWithWorkerResponse(Mapping):
        pass

    class CreateAdditionalAssignmentsForHITRequest(Mapping):
        pass

    class CreateAdditionalAssignmentsForHITResponse(Mapping):
        pass

    class CreateHITRequest(Mapping):
        pass

    class CreateHITResponse(Mapping):
        pass

    class Long(object):
        pass

    class QualificationRequirement(Mapping):
        pass

    class ReviewPolicy(Mapping):
        pass

    class HITLayoutParameter(Mapping):
        pass

    class CreateHITTypeRequest(Mapping):
        pass

    class CreateHITTypeResponse(Mapping):
        pass

    class CreateHITWithHITTypeRequest(Mapping):
        pass

    class CreateHITWithHITTypeResponse(Mapping):
        pass

    class CreateQualificationTypeRequest(Mapping):
        pass

    class CreateQualificationTypeResponse(Mapping):
        pass

    class CreateWorkerBlockRequest(Mapping):
        pass

    class CreateWorkerBlockResponse(Mapping):
        pass

    class DeleteHITRequest(Mapping):
        pass

    class DeleteHITResponse(Mapping):
        pass

    class DeleteQualificationTypeRequest(Mapping):
        pass

    class DeleteQualificationTypeResponse(Mapping):
        pass

    class DeleteWorkerBlockRequest(Mapping):
        pass

    class DeleteWorkerBlockResponse(Mapping):
        pass

    class DisassociateQualificationFromWorkerRequest(Mapping):
        pass

    class DisassociateQualificationFromWorkerResponse(Mapping):
        pass

    class GetAccountBalanceRequest(Mapping):
        pass

    class GetAccountBalanceResponse(Mapping):
        pass

    class GetAssignmentRequest(Mapping):
        pass

    class GetAssignmentResponse(Mapping):
        pass

    class GetFileUploadURLRequest(Mapping):
        pass

    class GetFileUploadURLResponse(Mapping):
        pass

    class GetHITRequest(Mapping):
        pass

    class GetHITResponse(Mapping):
        pass

    class GetQualificationScoreRequest(Mapping):
        pass

    class GetQualificationScoreResponse(Mapping):
        pass

    class GetQualificationTypeRequest(Mapping):
        pass

    class GetQualificationTypeResponse(Mapping):
        pass

    class ListAssignmentsForHITRequest(Mapping):
        pass

    class ListAssignmentsForHITResponse(Mapping):
        pass

    class AssignmentStatus(object):
        pass

    class ListBonusPaymentsRequest(Mapping):
        pass

    class ListBonusPaymentsResponse(Mapping):
        pass

    class ListHITsRequest(Mapping):
        pass

    class ListHITsResponse(Mapping):
        pass

    class ListHITsForQualificationTypeRequest(Mapping):
        pass

    class ListHITsForQualificationTypeResponse(Mapping):
        pass

    class ListQualificationRequestsRequest(Mapping):
        pass

    class ListQualificationRequestsResponse(Mapping):
        pass

    class ListQualificationTypesRequest(Mapping):
        pass

    class ListQualificationTypesResponse(Mapping):
        pass

    class ListReviewPolicyResultsForHITRequest(Mapping):
        pass

    class ListReviewPolicyResultsForHITResponse(Mapping):
        pass

    class ReviewPolicyLevel(object):
        pass

    class ListReviewableHITsRequest(Mapping):
        pass

    class ListReviewableHITsResponse(Mapping):
        pass

    class ListWorkerBlocksRequest(Mapping):
        pass

    class ListWorkerBlocksResponse(Mapping):
        pass

    class ListWorkersWithQualificationTypeRequest(Mapping):
        pass

    class ListWorkersWithQualificationTypeResponse(Mapping):
        pass

    class NotifyWorkersRequest(Mapping):
        pass

    class NotifyWorkersResponse(Mapping):
        pass

    class CustomerId(object):
        pass

    class RejectAssignmentRequest(Mapping):
        pass

    class RejectAssignmentResponse(Mapping):
        pass

    class RejectQualificationRequestRequest(Mapping):
        pass

    class RejectQualificationRequestResponse(Mapping):
        pass

    class SendBonusRequest(Mapping):
        pass

    class SendBonusResponse(Mapping):
        pass

    class SendTestEventNotificationRequest(Mapping):
        pass

    class SendTestEventNotificationResponse(Mapping):
        pass

    class NotificationSpecification(Mapping):
        pass

    class UpdateExpirationForHITRequest(Mapping):
        pass

    class UpdateExpirationForHITResponse(Mapping):
        pass

    class Timestamp(object):
        pass

    class UpdateHITReviewStatusRequest(Mapping):
        pass

    class UpdateHITReviewStatusResponse(Mapping):
        pass

    class UpdateHITTypeOfHITRequest(Mapping):
        pass

    class UpdateHITTypeOfHITResponse(Mapping):
        pass

    class UpdateNotificationSettingsRequest(Mapping):
        pass

    class UpdateNotificationSettingsResponse(Mapping):
        pass

    class UpdateQualificationTypeRequest(Mapping):
        pass

    class UpdateQualificationTypeResponse(Mapping):
        pass

    def accept_qualification_request(self, QualificationRequestId: str, IntegerValue: int=None) -> AcceptQualificationRequestResponse:
        pass

    def approve_assignment(self, AssignmentId: str, RequesterFeedback: str=None, OverrideRejection: Boolean=None) -> ApproveAssignmentResponse:
        pass

    def associate_qualification_with_worker(self, WorkerId: str, QualificationTypeId: str, IntegerValue: int=None, SendNotification: Boolean=None) -> AssociateQualificationWithWorkerResponse:
        pass

    def create_additional_assignments_for_hit(self, NumberOfAdditionalAssignments: int, HITId: str, UniqueRequestToken: str=None) -> CreateAdditionalAssignmentsForHITResponse:
        pass

    def create_hit(self, Description: str, Title: str, Reward: str, AssignmentDurationInSeconds: Long, LifetimeInSeconds: Long, MaxAssignments: int=None, AutoApprovalDelayInSeconds: Long=None, Keywords: str=None, Question: str=None, RequesterAnnotation: str=None, QualificationRequirements: List[QualificationRequirement]=None, UniqueRequestToken: str=None, AssignmentReviewPolicy: ReviewPolicy=None, HITReviewPolicy: ReviewPolicy=None, HITLayoutId: str=None, HITLayoutParameters: List[HITLayoutParameter]=None) -> CreateHITResponse:
        pass

    def create_hit_type(self, Description: str, Title: str, Reward: str, AssignmentDurationInSeconds: Long, AutoApprovalDelayInSeconds: Long=None, Keywords: str=None, QualificationRequirements: List[QualificationRequirement]=None) -> CreateHITTypeResponse:
        pass

    def create_hit_with_hit_type(self, LifetimeInSeconds: Long, HITTypeId: str, MaxAssignments: int=None, Question: str=None, RequesterAnnotation: str=None, UniqueRequestToken: str=None, AssignmentReviewPolicy: ReviewPolicy=None, HITReviewPolicy: ReviewPolicy=None, HITLayoutId: str=None, HITLayoutParameters: List[HITLayoutParameter]=None) -> CreateHITWithHITTypeResponse:
        pass

    def create_qualification_type(self, QualificationTypeStatus: str, Description: str, Name: str, Keywords: str=None, RetryDelayInSeconds: Long=None, Test: str=None, AnswerKey: str=None, TestDurationInSeconds: Long=None, AutoGranted: Boolean=None, AutoGrantedValue: int=None) -> CreateQualificationTypeResponse:
        pass

    def create_worker_block(self, Reason: str, WorkerId: str) -> CreateWorkerBlockResponse:
        pass

    def delete_hit(self, HITId: str) -> DeleteHITResponse:
        pass

    def delete_qualification_type(self, QualificationTypeId: str) -> DeleteQualificationTypeResponse:
        pass

    def delete_worker_block(self, WorkerId: str, Reason: str=None) -> DeleteWorkerBlockResponse:
        pass

    def disassociate_qualification_from_worker(self, QualificationTypeId: str, WorkerId: str, Reason: str=None) -> DisassociateQualificationFromWorkerResponse:
        pass

    def get_account_balance(self) -> GetAccountBalanceResponse:
        pass

    def get_assignment(self, AssignmentId: str) -> GetAssignmentResponse:
        pass

    def get_file_upload_url(self, QuestionIdentifier: str, AssignmentId: str) -> GetFileUploadURLResponse:
        pass

    def get_hit(self, HITId: str) -> GetHITResponse:
        pass

    def get_qualification_score(self, WorkerId: str, QualificationTypeId: str) -> GetQualificationScoreResponse:
        pass

    def get_qualification_type(self, QualificationTypeId: str) -> GetQualificationTypeResponse:
        pass

    def list_assignments_for_hit(self, HITId: str, NextToken: str=None, MaxResults: int=None, AssignmentStatuses: List[AssignmentStatus]=None) -> ListAssignmentsForHITResponse:
        pass

    def list_bonus_payments(self, HITId: str=None, AssignmentId: str=None, NextToken: str=None, MaxResults: int=None) -> ListBonusPaymentsResponse:
        pass

    def list_hits(self, NextToken: str=None, MaxResults: int=None) -> ListHITsResponse:
        pass

    def list_hits_for_qualification_type(self, QualificationTypeId: str, NextToken: str=None, MaxResults: int=None) -> ListHITsForQualificationTypeResponse:
        pass

    def list_qualification_requests(self, QualificationTypeId: str=None, NextToken: str=None, MaxResults: int=None) -> ListQualificationRequestsResponse:
        pass

    def list_qualification_types(self, MustBeRequestable: Boolean, Query: str=None, MustBeOwnedByCaller: Boolean=None, NextToken: str=None, MaxResults: int=None) -> ListQualificationTypesResponse:
        pass

    def list_review_policy_results_for_hit(self, HITId: str, PolicyLevels: List[ReviewPolicyLevel]=None, RetrieveActions: Boolean=None, RetrieveResults: Boolean=None, NextToken: str=None, MaxResults: int=None) -> ListReviewPolicyResultsForHITResponse:
        pass

    def list_reviewable_hits(self, HITTypeId: str=None, Status: str=None, NextToken: str=None, MaxResults: int=None) -> ListReviewableHITsResponse:
        pass

    def list_worker_blocks(self, NextToken: str=None, MaxResults: int=None) -> ListWorkerBlocksResponse:
        pass

    def list_workers_with_qualification_type(self, QualificationTypeId: str, Status: str=None, NextToken: str=None, MaxResults: int=None) -> ListWorkersWithQualificationTypeResponse:
        pass

    def notify_workers(self, WorkerIds: List[CustomerId], MessageText: str, Subject: str) -> NotifyWorkersResponse:
        pass

    def reject_assignment(self, RequesterFeedback: str, AssignmentId: str) -> RejectAssignmentResponse:
        pass

    def reject_qualification_request(self, QualificationRequestId: str, Reason: str=None) -> RejectQualificationRequestResponse:
        pass

    def send_bonus(self, Reason: str, AssignmentId: str, BonusAmount: str, WorkerId: str, UniqueRequestToken: str=None) -> SendBonusResponse:
        pass

    def send_test_event_notification(self, TestEventType: str, Notification: NotificationSpecification) -> SendTestEventNotificationResponse:
        pass

    def update_expiration_for_hit(self, ExpireAt: Timestamp, HITId: str) -> UpdateExpirationForHITResponse:
        pass

    def update_hit_review_status(self, HITId: str, Revert: Boolean=None) -> UpdateHITReviewStatusResponse:
        pass

    def update_hit_type_of_hit(self, HITTypeId: str, HITId: str) -> UpdateHITTypeOfHITResponse:
        pass

    def update_notification_settings(self, HITTypeId: str, Notification: NotificationSpecification=None, Active: Boolean=None) -> UpdateNotificationSettingsResponse:
        pass

    def update_qualification_type(self, QualificationTypeId: str, Description: str=None, QualificationTypeStatus: str=None, Test: str=None, AnswerKey: str=None, TestDurationInSeconds: Long=None, RetryDelayInSeconds: Long=None, AutoGranted: Boolean=None, AutoGrantedValue: int=None) -> UpdateQualificationTypeResponse:
        pass


class Neptune(BaseClient):
    class AddRoleToDBClusterMessage(Mapping):
        pass

    class AddSourceIdentifierToSubscriptionMessage(Mapping):
        pass

    class AddSourceIdentifierToSubscriptionResult(Mapping):
        pass

    class AddTagsToResourceMessage(Mapping):
        pass

    class Tag(Mapping):
        pass

    class ApplyPendingMaintenanceActionMessage(Mapping):
        pass

    class ApplyPendingMaintenanceActionResult(Mapping):
        pass

    class CopyDBClusterParameterGroupMessage(Mapping):
        pass

    class CopyDBClusterParameterGroupResult(Mapping):
        pass

    class CopyDBClusterSnapshotMessage(Mapping):
        pass

    class CopyDBClusterSnapshotResult(Mapping):
        pass

    class BooleanOptional(object):
        pass

    class CopyDBParameterGroupMessage(Mapping):
        pass

    class CopyDBParameterGroupResult(Mapping):
        pass

    class CreateDBClusterMessage(Mapping):
        pass

    class CreateDBClusterResult(Mapping):
        pass

    class String(object):
        pass

    class CreateDBClusterParameterGroupMessage(Mapping):
        pass

    class CreateDBClusterParameterGroupResult(Mapping):
        pass

    class CreateDBClusterSnapshotMessage(Mapping):
        pass

    class CreateDBClusterSnapshotResult(Mapping):
        pass

    class CreateDBInstanceMessage(Mapping):
        pass

    class CreateDBInstanceResult(Mapping):
        pass

    class CreateDBParameterGroupMessage(Mapping):
        pass

    class CreateDBParameterGroupResult(Mapping):
        pass

    class CreateDBSubnetGroupMessage(Mapping):
        pass

    class CreateDBSubnetGroupResult(Mapping):
        pass

    class CreateEventSubscriptionMessage(Mapping):
        pass

    class CreateEventSubscriptionResult(Mapping):
        pass

    class DeleteDBClusterMessage(Mapping):
        pass

    class DeleteDBClusterResult(Mapping):
        pass

    class Boolean(object):
        pass

    class DeleteDBClusterParameterGroupMessage(Mapping):
        pass

    class DeleteDBClusterSnapshotMessage(Mapping):
        pass

    class DeleteDBClusterSnapshotResult(Mapping):
        pass

    class DeleteDBInstanceMessage(Mapping):
        pass

    class DeleteDBInstanceResult(Mapping):
        pass

    class DeleteDBParameterGroupMessage(Mapping):
        pass

    class DeleteDBSubnetGroupMessage(Mapping):
        pass

    class DeleteEventSubscriptionMessage(Mapping):
        pass

    class DeleteEventSubscriptionResult(Mapping):
        pass

    class DescribeDBClusterParameterGroupsMessage(Mapping):
        pass

    class DBClusterParameterGroupsMessage(Mapping):
        pass

    class Filter(Mapping):
        pass

    class DescribeDBClusterParametersMessage(Mapping):
        pass

    class DBClusterParameterGroupDetails(Mapping):
        pass

    class DescribeDBClusterSnapshotAttributesMessage(Mapping):
        pass

    class DescribeDBClusterSnapshotAttributesResult(Mapping):
        pass

    class DescribeDBClusterSnapshotsMessage(Mapping):
        pass

    class DBClusterSnapshotMessage(Mapping):
        pass

    class DescribeDBClustersMessage(Mapping):
        pass

    class DBClusterMessage(Mapping):
        pass

    class DescribeDBEngineVersionsMessage(Mapping):
        pass

    class DBEngineVersionMessage(Mapping):
        pass

    class DescribeDBInstancesMessage(Mapping):
        pass

    class DBInstanceMessage(Mapping):
        pass

    class DescribeDBParameterGroupsMessage(Mapping):
        pass

    class DBParameterGroupsMessage(Mapping):
        pass

    class DescribeDBParametersMessage(Mapping):
        pass

    class DBParameterGroupDetails(Mapping):
        pass

    class DescribeDBSubnetGroupsMessage(Mapping):
        pass

    class DBSubnetGroupMessage(Mapping):
        pass

    class DescribeEngineDefaultClusterParametersMessage(Mapping):
        pass

    class DescribeEngineDefaultClusterParametersResult(Mapping):
        pass

    class DescribeEngineDefaultParametersMessage(Mapping):
        pass

    class DescribeEngineDefaultParametersResult(Mapping):
        pass

    class DescribeEventCategoriesMessage(Mapping):
        pass

    class EventCategoriesMessage(Mapping):
        pass

    class DescribeEventSubscriptionsMessage(Mapping):
        pass

    class EventSubscriptionsMessage(Mapping):
        pass

    class DescribeEventsMessage(Mapping):
        pass

    class EventsMessage(Mapping):
        pass

    class TStamp(object):
        pass

    class DescribeOrderableDBInstanceOptionsMessage(Mapping):
        pass

    class OrderableDBInstanceOptionsMessage(Mapping):
        pass

    class DescribePendingMaintenanceActionsMessage(Mapping):
        pass

    class PendingMaintenanceActionsMessage(Mapping):
        pass

    class DescribeValidDBInstanceModificationsMessage(Mapping):
        pass

    class DescribeValidDBInstanceModificationsResult(Mapping):
        pass

    class FailoverDBClusterMessage(Mapping):
        pass

    class FailoverDBClusterResult(Mapping):
        pass

    class ListTagsForResourceMessage(Mapping):
        pass

    class TagListMessage(Mapping):
        pass

    class ModifyDBClusterMessage(Mapping):
        pass

    class ModifyDBClusterResult(Mapping):
        pass

    class ModifyDBClusterParameterGroupMessage(Mapping):
        pass

    class DBClusterParameterGroupNameMessage(Mapping):
        pass

    class Parameter(Mapping):
        pass

    class ModifyDBClusterSnapshotAttributeMessage(Mapping):
        pass

    class ModifyDBClusterSnapshotAttributeResult(Mapping):
        pass

    class ModifyDBInstanceMessage(Mapping):
        pass

    class ModifyDBInstanceResult(Mapping):
        pass

    class CloudwatchLogsExportConfiguration(Mapping):
        pass

    class ModifyDBParameterGroupMessage(Mapping):
        pass

    class DBParameterGroupNameMessage(Mapping):
        pass

    class ModifyDBSubnetGroupMessage(Mapping):
        pass

    class ModifyDBSubnetGroupResult(Mapping):
        pass

    class ModifyEventSubscriptionMessage(Mapping):
        pass

    class ModifyEventSubscriptionResult(Mapping):
        pass

    class PromoteReadReplicaDBClusterMessage(Mapping):
        pass

    class PromoteReadReplicaDBClusterResult(Mapping):
        pass

    class RebootDBInstanceMessage(Mapping):
        pass

    class RebootDBInstanceResult(Mapping):
        pass

    class RemoveRoleFromDBClusterMessage(Mapping):
        pass

    class RemoveSourceIdentifierFromSubscriptionMessage(Mapping):
        pass

    class RemoveSourceIdentifierFromSubscriptionResult(Mapping):
        pass

    class RemoveTagsFromResourceMessage(Mapping):
        pass

    class ResetDBClusterParameterGroupMessage(Mapping):
        pass

    class ResetDBParameterGroupMessage(Mapping):
        pass

    class RestoreDBClusterFromSnapshotMessage(Mapping):
        pass

    class RestoreDBClusterFromSnapshotResult(Mapping):
        pass

    class RestoreDBClusterToPointInTimeMessage(Mapping):
        pass

    class RestoreDBClusterToPointInTimeResult(Mapping):
        pass

    def add_role_to_db_cluster(self, RoleArn: str, DBClusterIdentifier: str):
        pass

    def add_source_identifier_to_subscription(self, SourceIdentifier: str, SubscriptionName: str) -> AddSourceIdentifierToSubscriptionResult:
        pass

    def add_tags_to_resource(self, Tags: List[Tag], ResourceName: str):
        pass

    def apply_pending_maintenance_action(self, OptInType: str, ApplyAction: str, ResourceIdentifier: str) -> ApplyPendingMaintenanceActionResult:
        pass

    def copy_db_cluster_parameter_group(self, TargetDBClusterParameterGroupDescription: str, TargetDBClusterParameterGroupIdentifier: str, SourceDBClusterParameterGroupIdentifier: str, Tags: List[Tag]=None) -> CopyDBClusterParameterGroupResult:
        pass

    def copy_db_cluster_snapshot(self, TargetDBClusterSnapshotIdentifier: str, SourceDBClusterSnapshotIdentifier: str, KmsKeyId: str=None, PreSignedUrl: str=None, CopyTags: BooleanOptional=None, Tags: List[Tag]=None, SourceRegion: str=None) -> CopyDBClusterSnapshotResult:
        pass

    def copy_db_parameter_group(self, TargetDBParameterGroupDescription: str, TargetDBParameterGroupIdentifier: str, SourceDBParameterGroupIdentifier: str, Tags: List[Tag]=None) -> CopyDBParameterGroupResult:
        pass

    def create_db_cluster(self, Engine: str, DBClusterIdentifier: str, AvailabilityZones: List[String]=None, BackupRetentionPeriod: int=None, CharacterSetName: str=None, DatabaseName: str=None, DBClusterParameterGroupName: str=None, VpcSecurityGroupIds: List[String]=None, DBSubnetGroupName: str=None, EngineVersion: str=None, Port: int=None, MasterUsername: str=None, MasterUserPassword: str=None, OptionGroupName: str=None, PreferredBackupWindow: str=None, PreferredMaintenanceWindow: str=None, ReplicationSourceIdentifier: str=None, Tags: List[Tag]=None, StorageEncrypted: BooleanOptional=None, KmsKeyId: str=None, PreSignedUrl: str=None, EnableIAMDatabaseAuthentication: BooleanOptional=None, SourceRegion: str=None) -> CreateDBClusterResult:
        pass

    def create_db_cluster_parameter_group(self, Description: str, DBParameterGroupFamily: str, DBClusterParameterGroupName: str, Tags: List[Tag]=None) -> CreateDBClusterParameterGroupResult:
        pass

    def create_db_cluster_snapshot(self, DBClusterIdentifier: str, DBClusterSnapshotIdentifier: str, Tags: List[Tag]=None) -> CreateDBClusterSnapshotResult:
        pass

    def create_db_instance(self, Engine: str, DBInstanceClass: str, DBInstanceIdentifier: str, DBName: str=None, AllocatedStorage: int=None, MasterUsername: str=None, MasterUserPassword: str=None, DBSecurityGroups: List[String]=None, VpcSecurityGroupIds: List[String]=None, AvailabilityZone: str=None, DBSubnetGroupName: str=None, PreferredMaintenanceWindow: str=None, DBParameterGroupName: str=None, BackupRetentionPeriod: int=None, PreferredBackupWindow: str=None, Port: int=None, MultiAZ: BooleanOptional=None, EngineVersion: str=None, AutoMinorVersionUpgrade: BooleanOptional=None, LicenseModel: str=None, Iops: int=None, OptionGroupName: str=None, CharacterSetName: str=None, PubliclyAccessible: BooleanOptional=None, Tags: List[Tag]=None, DBClusterIdentifier: str=None, StorageType: str=None, TdeCredentialArn: str=None, TdeCredentialPassword: str=None, StorageEncrypted: BooleanOptional=None, KmsKeyId: str=None, Domain: str=None, CopyTagsToSnapshot: BooleanOptional=None, MonitoringInterval: int=None, MonitoringRoleArn: str=None, DomainIAMRoleName: str=None, PromotionTier: int=None, Timezone: str=None, EnableIAMDatabaseAuthentication: BooleanOptional=None, EnablePerformanceInsights: BooleanOptional=None, PerformanceInsightsKMSKeyId: str=None, EnableCloudwatchLogsExports: List[String]=None) -> CreateDBInstanceResult:
        pass

    def create_db_parameter_group(self, Description: str, DBParameterGroupFamily: str, DBParameterGroupName: str, Tags: List[Tag]=None) -> CreateDBParameterGroupResult:
        pass

    def create_db_subnet_group(self, SubnetIds: List[String], DBSubnetGroupDescription: str, DBSubnetGroupName: str, Tags: List[Tag]=None) -> CreateDBSubnetGroupResult:
        pass

    def create_event_subscription(self, SnsTopicArn: str, SubscriptionName: str, SourceType: str=None, EventCategories: List[String]=None, SourceIds: List[String]=None, Enabled: BooleanOptional=None, Tags: List[Tag]=None) -> CreateEventSubscriptionResult:
        pass

    def delete_db_cluster(self, DBClusterIdentifier: str, SkipFinalSnapshot: Boolean=None, FinalDBSnapshotIdentifier: str=None) -> DeleteDBClusterResult:
        pass

    def delete_db_cluster_parameter_group(self, DBClusterParameterGroupName: str):
        pass

    def delete_db_cluster_snapshot(self, DBClusterSnapshotIdentifier: str) -> DeleteDBClusterSnapshotResult:
        pass

    def delete_db_instance(self, DBInstanceIdentifier: str, SkipFinalSnapshot: Boolean=None, FinalDBSnapshotIdentifier: str=None) -> DeleteDBInstanceResult:
        pass

    def delete_db_parameter_group(self, DBParameterGroupName: str):
        pass

    def delete_db_subnet_group(self, DBSubnetGroupName: str):
        pass

    def delete_event_subscription(self, SubscriptionName: str) -> DeleteEventSubscriptionResult:
        pass

    def describe_db_cluster_parameter_groups(self, DBClusterParameterGroupName: str=None, Filters: List[Filter]=None, MaxRecords: int=None, Marker: str=None) -> DBClusterParameterGroupsMessage:
        pass

    def describe_db_cluster_parameters(self, DBClusterParameterGroupName: str, Source: str=None, Filters: List[Filter]=None, MaxRecords: int=None, Marker: str=None) -> DBClusterParameterGroupDetails:
        pass

    def describe_db_cluster_snapshot_attributes(self, DBClusterSnapshotIdentifier: str) -> DescribeDBClusterSnapshotAttributesResult:
        pass

    def describe_db_cluster_snapshots(self, DBClusterIdentifier: str=None, DBClusterSnapshotIdentifier: str=None, SnapshotType: str=None, Filters: List[Filter]=None, MaxRecords: int=None, Marker: str=None, IncludeShared: Boolean=None, IncludePublic: Boolean=None) -> DBClusterSnapshotMessage:
        pass

    def describe_db_clusters(self, DBClusterIdentifier: str=None, Filters: List[Filter]=None, MaxRecords: int=None, Marker: str=None) -> DBClusterMessage:
        pass

    def describe_db_engine_versions(self, Engine: str=None, EngineVersion: str=None, DBParameterGroupFamily: str=None, Filters: List[Filter]=None, MaxRecords: int=None, Marker: str=None, DefaultOnly: Boolean=None, ListSupportedCharacterSets: BooleanOptional=None, ListSupportedTimezones: BooleanOptional=None) -> DBEngineVersionMessage:
        pass

    def describe_db_instances(self, DBInstanceIdentifier: str=None, Filters: List[Filter]=None, MaxRecords: int=None, Marker: str=None) -> DBInstanceMessage:
        pass

    def describe_db_parameter_groups(self, DBParameterGroupName: str=None, Filters: List[Filter]=None, MaxRecords: int=None, Marker: str=None) -> DBParameterGroupsMessage:
        pass

    def describe_db_parameters(self, DBParameterGroupName: str, Source: str=None, Filters: List[Filter]=None, MaxRecords: int=None, Marker: str=None) -> DBParameterGroupDetails:
        pass

    def describe_db_subnet_groups(self, DBSubnetGroupName: str=None, Filters: List[Filter]=None, MaxRecords: int=None, Marker: str=None) -> DBSubnetGroupMessage:
        pass

    def describe_engine_default_cluster_parameters(self, DBParameterGroupFamily: str, Filters: List[Filter]=None, MaxRecords: int=None, Marker: str=None) -> DescribeEngineDefaultClusterParametersResult:
        pass

    def describe_engine_default_parameters(self, DBParameterGroupFamily: str, Filters: List[Filter]=None, MaxRecords: int=None, Marker: str=None) -> DescribeEngineDefaultParametersResult:
        pass

    def describe_event_categories(self, SourceType: str=None, Filters: List[Filter]=None) -> EventCategoriesMessage:
        pass

    def describe_event_subscriptions(self, SubscriptionName: str=None, Filters: List[Filter]=None, MaxRecords: int=None, Marker: str=None) -> EventSubscriptionsMessage:
        pass

    def describe_events(self, SourceIdentifier: str=None, SourceType: str=None, StartTime: TStamp=None, EndTime: TStamp=None, Duration: int=None, EventCategories: List[String]=None, Filters: List[Filter]=None, MaxRecords: int=None, Marker: str=None) -> EventsMessage:
        pass

    def describe_orderable_db_instance_options(self, Engine: str, EngineVersion: str=None, DBInstanceClass: str=None, LicenseModel: str=None, Vpc: BooleanOptional=None, Filters: List[Filter]=None, MaxRecords: int=None, Marker: str=None) -> OrderableDBInstanceOptionsMessage:
        pass

    def describe_pending_maintenance_actions(self, ResourceIdentifier: str=None, Filters: List[Filter]=None, Marker: str=None, MaxRecords: int=None) -> PendingMaintenanceActionsMessage:
        pass

    def describe_valid_db_instance_modifications(self, DBInstanceIdentifier: str) -> DescribeValidDBInstanceModificationsResult:
        pass

    def failover_db_cluster(self, DBClusterIdentifier: str=None, TargetDBInstanceIdentifier: str=None) -> FailoverDBClusterResult:
        pass

    def list_tags_for_resource(self, ResourceName: str, Filters: List[Filter]=None) -> TagListMessage:
        pass

    def modify_db_cluster(self, DBClusterIdentifier: str, NewDBClusterIdentifier: str=None, ApplyImmediately: Boolean=None, BackupRetentionPeriod: int=None, DBClusterParameterGroupName: str=None, VpcSecurityGroupIds: List[String]=None, Port: int=None, MasterUserPassword: str=None, OptionGroupName: str=None, PreferredBackupWindow: str=None, PreferredMaintenanceWindow: str=None, EnableIAMDatabaseAuthentication: BooleanOptional=None, EngineVersion: str=None) -> ModifyDBClusterResult:
        pass

    def modify_db_cluster_parameter_group(self, Parameters: List[Parameter], DBClusterParameterGroupName: str) -> DBClusterParameterGroupNameMessage:
        pass

    def modify_db_cluster_snapshot_attribute(self, AttributeName: str, DBClusterSnapshotIdentifier: str, ValuesToAdd: List[String]=None, ValuesToRemove: List[String]=None) -> ModifyDBClusterSnapshotAttributeResult:
        pass

    def modify_db_instance(self, DBInstanceIdentifier: str, AllocatedStorage: int=None, DBInstanceClass: str=None, DBSubnetGroupName: str=None, DBSecurityGroups: List[String]=None, VpcSecurityGroupIds: List[String]=None, ApplyImmediately: Boolean=None, MasterUserPassword: str=None, DBParameterGroupName: str=None, BackupRetentionPeriod: int=None, PreferredBackupWindow: str=None, PreferredMaintenanceWindow: str=None, MultiAZ: BooleanOptional=None, EngineVersion: str=None, AllowMajorVersionUpgrade: Boolean=None, AutoMinorVersionUpgrade: BooleanOptional=None, LicenseModel: str=None, Iops: int=None, OptionGroupName: str=None, NewDBInstanceIdentifier: str=None, StorageType: str=None, TdeCredentialArn: str=None, TdeCredentialPassword: str=None, CACertificateIdentifier: str=None, Domain: str=None, CopyTagsToSnapshot: BooleanOptional=None, MonitoringInterval: int=None, DBPortNumber: int=None, PubliclyAccessible: BooleanOptional=None, MonitoringRoleArn: str=None, DomainIAMRoleName: str=None, PromotionTier: int=None, EnableIAMDatabaseAuthentication: BooleanOptional=None, EnablePerformanceInsights: BooleanOptional=None, PerformanceInsightsKMSKeyId: str=None, CloudwatchLogsExportConfiguration: CloudwatchLogsExportConfiguration=None) -> ModifyDBInstanceResult:
        pass

    def modify_db_parameter_group(self, Parameters: List[Parameter], DBParameterGroupName: str) -> DBParameterGroupNameMessage:
        pass

    def modify_db_subnet_group(self, SubnetIds: List[String], DBSubnetGroupName: str, DBSubnetGroupDescription: str=None) -> ModifyDBSubnetGroupResult:
        pass

    def modify_event_subscription(self, SubscriptionName: str, SnsTopicArn: str=None, SourceType: str=None, EventCategories: List[String]=None, Enabled: BooleanOptional=None) -> ModifyEventSubscriptionResult:
        pass

    def promote_read_replica_db_cluster(self, DBClusterIdentifier: str) -> PromoteReadReplicaDBClusterResult:
        pass

    def reboot_db_instance(self, DBInstanceIdentifier: str, ForceFailover: BooleanOptional=None) -> RebootDBInstanceResult:
        pass

    def remove_role_from_db_cluster(self, RoleArn: str, DBClusterIdentifier: str):
        pass

    def remove_source_identifier_from_subscription(self, SourceIdentifier: str, SubscriptionName: str) -> RemoveSourceIdentifierFromSubscriptionResult:
        pass

    def remove_tags_from_resource(self, TagKeys: List[String], ResourceName: str):
        pass

    def reset_db_cluster_parameter_group(self, DBClusterParameterGroupName: str, ResetAllParameters: Boolean=None, Parameters: List[Parameter]=None) -> DBClusterParameterGroupNameMessage:
        pass

    def reset_db_parameter_group(self, DBParameterGroupName: str, ResetAllParameters: Boolean=None, Parameters: List[Parameter]=None) -> DBParameterGroupNameMessage:
        pass

    def restore_db_cluster_from_snapshot(self, Engine: str, SnapshotIdentifier: str, DBClusterIdentifier: str, AvailabilityZones: List[String]=None, EngineVersion: str=None, Port: int=None, DBSubnetGroupName: str=None, DatabaseName: str=None, OptionGroupName: str=None, VpcSecurityGroupIds: List[String]=None, Tags: List[Tag]=None, KmsKeyId: str=None, EnableIAMDatabaseAuthentication: BooleanOptional=None) -> RestoreDBClusterFromSnapshotResult:
        pass

    def restore_db_cluster_to_point_in_time(self, SourceDBClusterIdentifier: str, DBClusterIdentifier: str, RestoreType: str=None, RestoreToTime: TStamp=None, UseLatestRestorableTime: Boolean=None, Port: int=None, DBSubnetGroupName: str=None, OptionGroupName: str=None, VpcSecurityGroupIds: List[String]=None, Tags: List[Tag]=None, KmsKeyId: str=None, EnableIAMDatabaseAuthentication: BooleanOptional=None) -> RestoreDBClusterToPointInTimeResult:
        pass


class OpsWorks(BaseClient):
    class AssignInstanceRequest(Mapping):
        pass

    class String(object):
        pass

    class AssignVolumeRequest(Mapping):
        pass

    class AssociateElasticIpRequest(Mapping):
        pass

    class AttachElasticLoadBalancerRequest(Mapping):
        pass

    class CloneStackRequest(Mapping):
        pass

    class CloneStackResult(Mapping):
        pass

    class StackAttributes(object):
        pass

    class StackConfigurationManager(Mapping):
        pass

    class ChefConfiguration(Mapping):
        pass

    class Boolean(object):
        pass

    class Source(Mapping):
        pass

    class CreateAppRequest(Mapping):
        pass

    class CreateAppResult(Mapping):
        pass

    class DataSource(Mapping):
        pass

    class SslConfiguration(Mapping):
        pass

    class AppAttributes(object):
        pass

    class EnvironmentVariable(Mapping):
        pass

    class CreateDeploymentRequest(Mapping):
        pass

    class CreateDeploymentResult(Mapping):
        pass

    class DeploymentCommand(Mapping):
        pass

    class CreateInstanceRequest(Mapping):
        pass

    class CreateInstanceResult(Mapping):
        pass

    class BlockDeviceMapping(Mapping):
        pass

    class CreateLayerRequest(Mapping):
        pass

    class CreateLayerResult(Mapping):
        pass

    class LayerAttributes(object):
        pass

    class CloudWatchLogsConfiguration(Mapping):
        pass

    class VolumeConfiguration(Mapping):
        pass

    class Recipes(Mapping):
        pass

    class LifecycleEventConfiguration(Mapping):
        pass

    class CreateStackRequest(Mapping):
        pass

    class CreateStackResult(Mapping):
        pass

    class CreateUserProfileRequest(Mapping):
        pass

    class CreateUserProfileResult(Mapping):
        pass

    class DeleteAppRequest(Mapping):
        pass

    class DeleteInstanceRequest(Mapping):
        pass

    class DeleteLayerRequest(Mapping):
        pass

    class DeleteStackRequest(Mapping):
        pass

    class DeleteUserProfileRequest(Mapping):
        pass

    class DeregisterEcsClusterRequest(Mapping):
        pass

    class DeregisterElasticIpRequest(Mapping):
        pass

    class DeregisterInstanceRequest(Mapping):
        pass

    class DeregisterRdsDbInstanceRequest(Mapping):
        pass

    class DeregisterVolumeRequest(Mapping):
        pass

    class DescribeAgentVersionsRequest(Mapping):
        pass

    class DescribeAgentVersionsResult(Mapping):
        pass

    class DescribeAppsRequest(Mapping):
        pass

    class DescribeAppsResult(Mapping):
        pass

    class DescribeCommandsRequest(Mapping):
        pass

    class DescribeCommandsResult(Mapping):
        pass

    class DescribeDeploymentsRequest(Mapping):
        pass

    class DescribeDeploymentsResult(Mapping):
        pass

    class DescribeEcsClustersRequest(Mapping):
        pass

    class DescribeEcsClustersResult(Mapping):
        pass

    class DescribeElasticIpsRequest(Mapping):
        pass

    class DescribeElasticIpsResult(Mapping):
        pass

    class DescribeElasticLoadBalancersRequest(Mapping):
        pass

    class DescribeElasticLoadBalancersResult(Mapping):
        pass

    class DescribeInstancesRequest(Mapping):
        pass

    class DescribeInstancesResult(Mapping):
        pass

    class DescribeLayersRequest(Mapping):
        pass

    class DescribeLayersResult(Mapping):
        pass

    class DescribeLoadBasedAutoScalingRequest(Mapping):
        pass

    class DescribeLoadBasedAutoScalingResult(Mapping):
        pass

    class DescribeMyUserProfileResult(Mapping):
        pass

    class DescribeOperatingSystemsResponse(Mapping):
        pass

    class DescribePermissionsRequest(Mapping):
        pass

    class DescribePermissionsResult(Mapping):
        pass

    class DescribeRaidArraysRequest(Mapping):
        pass

    class DescribeRaidArraysResult(Mapping):
        pass

    class DescribeRdsDbInstancesRequest(Mapping):
        pass

    class DescribeRdsDbInstancesResult(Mapping):
        pass

    class DescribeServiceErrorsRequest(Mapping):
        pass

    class DescribeServiceErrorsResult(Mapping):
        pass

    class DescribeStackProvisioningParametersRequest(Mapping):
        pass

    class DescribeStackProvisioningParametersResult(Mapping):
        pass

    class DescribeStackSummaryRequest(Mapping):
        pass

    class DescribeStackSummaryResult(Mapping):
        pass

    class DescribeStacksRequest(Mapping):
        pass

    class DescribeStacksResult(Mapping):
        pass

    class DescribeTimeBasedAutoScalingRequest(Mapping):
        pass

    class DescribeTimeBasedAutoScalingResult(Mapping):
        pass

    class DescribeUserProfilesRequest(Mapping):
        pass

    class DescribeUserProfilesResult(Mapping):
        pass

    class DescribeVolumesRequest(Mapping):
        pass

    class DescribeVolumesResult(Mapping):
        pass

    class DetachElasticLoadBalancerRequest(Mapping):
        pass

    class DisassociateElasticIpRequest(Mapping):
        pass

    class GetHostnameSuggestionRequest(Mapping):
        pass

    class GetHostnameSuggestionResult(Mapping):
        pass

    class GrantAccessRequest(Mapping):
        pass

    class GrantAccessResult(Mapping):
        pass

    class ListTagsRequest(Mapping):
        pass

    class ListTagsResult(Mapping):
        pass

    class RebootInstanceRequest(Mapping):
        pass

    class RegisterEcsClusterRequest(Mapping):
        pass

    class RegisterEcsClusterResult(Mapping):
        pass

    class RegisterElasticIpRequest(Mapping):
        pass

    class RegisterElasticIpResult(Mapping):
        pass

    class RegisterInstanceRequest(Mapping):
        pass

    class RegisterInstanceResult(Mapping):
        pass

    class InstanceIdentity(Mapping):
        pass

    class RegisterRdsDbInstanceRequest(Mapping):
        pass

    class RegisterVolumeRequest(Mapping):
        pass

    class RegisterVolumeResult(Mapping):
        pass

    class SetLoadBasedAutoScalingRequest(Mapping):
        pass

    class AutoScalingThresholds(Mapping):
        pass

    class SetPermissionRequest(Mapping):
        pass

    class SetTimeBasedAutoScalingRequest(Mapping):
        pass

    class WeeklyAutoScalingSchedule(Mapping):
        pass

    class StartInstanceRequest(Mapping):
        pass

    class StartStackRequest(Mapping):
        pass

    class StopInstanceRequest(Mapping):
        pass

    class StopStackRequest(Mapping):
        pass

    class TagResourceRequest(Mapping):
        pass

    class Tags(object):
        pass

    class UnassignInstanceRequest(Mapping):
        pass

    class UnassignVolumeRequest(Mapping):
        pass

    class UntagResourceRequest(Mapping):
        pass

    class TagKey(object):
        pass

    class UpdateAppRequest(Mapping):
        pass

    class UpdateElasticIpRequest(Mapping):
        pass

    class UpdateInstanceRequest(Mapping):
        pass

    class UpdateLayerRequest(Mapping):
        pass

    class UpdateMyUserProfileRequest(Mapping):
        pass

    class UpdateRdsDbInstanceRequest(Mapping):
        pass

    class UpdateStackRequest(Mapping):
        pass

    class UpdateUserProfileRequest(Mapping):
        pass

    class UpdateVolumeRequest(Mapping):
        pass

    def assign_instance(self, LayerIds: List[String], InstanceId: str):
        pass

    def assign_volume(self, VolumeId: str, InstanceId: str=None):
        pass

    def associate_elastic_ip(self, ElasticIp: str, InstanceId: str=None):
        pass

    def attach_elastic_load_balancer(self, LayerId: str, ElasticLoadBalancerName: str):
        pass

    def clone_stack(self, ServiceRoleArn: str, SourceStackId: str, Name: str=None, Region: str=None, VpcId: str=None, Attributes: StackAttributes=None, DefaultInstanceProfileArn: str=None, DefaultOs: str=None, HostnameTheme: str=None, DefaultAvailabilityZone: str=None, DefaultSubnetId: str=None, CustomJson: str=None, ConfigurationManager: StackConfigurationManager=None, ChefConfiguration: ChefConfiguration=None, UseCustomCookbooks: Boolean=None, UseOpsworksSecurityGroups: Boolean=None, CustomCookbooksSource: Source=None, DefaultSshKeyName: str=None, ClonePermissions: Boolean=None, CloneAppIds: List[String]=None, DefaultRootDeviceType: str=None, AgentVersion: str=None) -> CloneStackResult:
        pass

    def create_app(self, Type: str, Name: str, StackId: str, Shortname: str=None, Description: str=None, DataSources: List[DataSource]=None, AppSource: Source=None, Domains: List[String]=None, EnableSsl: Boolean=None, SslConfiguration: SslConfiguration=None, Attributes: AppAttributes=None, Environment: List[EnvironmentVariable]=None) -> CreateAppResult:
        pass

    def create_deployment(self, Command: DeploymentCommand, StackId: str, AppId: str=None, InstanceIds: List[String]=None, LayerIds: List[String]=None, Comment: str=None, CustomJson: str=None) -> CreateDeploymentResult:
        pass

    def create_instance(self, InstanceType: str, LayerIds: List[String], StackId: str, AutoScalingType: str=None, Hostname: str=None, Os: str=None, AmiId: str=None, SshKeyName: str=None, AvailabilityZone: str=None, VirtualizationType: str=None, SubnetId: str=None, Architecture: str=None, RootDeviceType: str=None, BlockDeviceMappings: List[BlockDeviceMapping]=None, InstallUpdatesOnBoot: Boolean=None, EbsOptimized: Boolean=None, AgentVersion: str=None, Tenancy: str=None) -> CreateInstanceResult:
        pass

    def create_layer(self, Shortname: str, Name: str, Type: str, StackId: str, Attributes: LayerAttributes=None, CloudWatchLogsConfiguration: CloudWatchLogsConfiguration=None, CustomInstanceProfileArn: str=None, CustomJson: str=None, CustomSecurityGroupIds: List[String]=None, Packages: List[String]=None, VolumeConfigurations: List[VolumeConfiguration]=None, EnableAutoHealing: Boolean=None, AutoAssignElasticIps: Boolean=None, AutoAssignPublicIps: Boolean=None, CustomRecipes: Recipes=None, InstallUpdatesOnBoot: Boolean=None, UseEbsOptimizedInstances: Boolean=None, LifecycleEventConfiguration: LifecycleEventConfiguration=None) -> CreateLayerResult:
        pass

    def create_stack(self, DefaultInstanceProfileArn: str, ServiceRoleArn: str, Region: str, Name: str, VpcId: str=None, Attributes: StackAttributes=None, DefaultOs: str=None, HostnameTheme: str=None, DefaultAvailabilityZone: str=None, DefaultSubnetId: str=None, CustomJson: str=None, ConfigurationManager: StackConfigurationManager=None, ChefConfiguration: ChefConfiguration=None, UseCustomCookbooks: Boolean=None, UseOpsworksSecurityGroups: Boolean=None, CustomCookbooksSource: Source=None, DefaultSshKeyName: str=None, DefaultRootDeviceType: str=None, AgentVersion: str=None) -> CreateStackResult:
        pass

    def create_user_profile(self, IamUserArn: str, SshUsername: str=None, SshPublicKey: str=None, AllowSelfManagement: Boolean=None) -> CreateUserProfileResult:
        pass

    def delete_app(self, AppId: str):
        pass

    def delete_instance(self, InstanceId: str, DeleteElasticIp: Boolean=None, DeleteVolumes: Boolean=None):
        pass

    def delete_layer(self, LayerId: str):
        pass

    def delete_stack(self, StackId: str):
        pass

    def delete_user_profile(self, IamUserArn: str):
        pass

    def deregister_ecs_cluster(self, EcsClusterArn: str):
        pass

    def deregister_elastic_ip(self, ElasticIp: str):
        pass

    def deregister_instance(self, InstanceId: str):
        pass

    def deregister_rds_db_instance(self, RdsDbInstanceArn: str):
        pass

    def deregister_volume(self, VolumeId: str):
        pass

    def describe_agent_versions(self, StackId: str=None, ConfigurationManager: StackConfigurationManager=None) -> DescribeAgentVersionsResult:
        pass

    def describe_apps(self, StackId: str=None, AppIds: List[String]=None) -> DescribeAppsResult:
        pass

    def describe_commands(self, DeploymentId: str=None, InstanceId: str=None, CommandIds: List[String]=None) -> DescribeCommandsResult:
        pass

    def describe_deployments(self, StackId: str=None, AppId: str=None, DeploymentIds: List[String]=None) -> DescribeDeploymentsResult:
        pass

    def describe_ecs_clusters(self, EcsClusterArns: List[String]=None, StackId: str=None, NextToken: str=None, MaxResults: int=None) -> DescribeEcsClustersResult:
        pass

    def describe_elastic_ips(self, InstanceId: str=None, StackId: str=None, Ips: List[String]=None) -> DescribeElasticIpsResult:
        pass

    def describe_elastic_load_balancers(self, StackId: str=None, LayerIds: List[String]=None) -> DescribeElasticLoadBalancersResult:
        pass

    def describe_instances(self, StackId: str=None, LayerId: str=None, InstanceIds: List[String]=None) -> DescribeInstancesResult:
        pass

    def describe_layers(self, StackId: str=None, LayerIds: List[String]=None) -> DescribeLayersResult:
        pass

    def describe_load_based_auto_scaling(self, LayerIds: List[String]) -> DescribeLoadBasedAutoScalingResult:
        pass

    def describe_my_user_profile(self) -> DescribeMyUserProfileResult:
        pass

    def describe_operating_systems(self) -> DescribeOperatingSystemsResponse:
        pass

    def describe_permissions(self, IamUserArn: str=None, StackId: str=None) -> DescribePermissionsResult:
        pass

    def describe_raid_arrays(self, InstanceId: str=None, StackId: str=None, RaidArrayIds: List[String]=None) -> DescribeRaidArraysResult:
        pass

    def describe_rds_db_instances(self, StackId: str, RdsDbInstanceArns: List[String]=None) -> DescribeRdsDbInstancesResult:
        pass

    def describe_service_errors(self, StackId: str=None, InstanceId: str=None, ServiceErrorIds: List[String]=None) -> DescribeServiceErrorsResult:
        pass

    def describe_stack_provisioning_parameters(self, StackId: str) -> DescribeStackProvisioningParametersResult:
        pass

    def describe_stack_summary(self, StackId: str) -> DescribeStackSummaryResult:
        pass

    def describe_stacks(self, StackIds: List[String]=None) -> DescribeStacksResult:
        pass

    def describe_time_based_auto_scaling(self, InstanceIds: List[String]) -> DescribeTimeBasedAutoScalingResult:
        pass

    def describe_user_profiles(self, IamUserArns: List[String]=None) -> DescribeUserProfilesResult:
        pass

    def describe_volumes(self, InstanceId: str=None, StackId: str=None, RaidArrayId: str=None, VolumeIds: List[String]=None) -> DescribeVolumesResult:
        pass

    def detach_elastic_load_balancer(self, LayerId: str, ElasticLoadBalancerName: str):
        pass

    def disassociate_elastic_ip(self, ElasticIp: str):
        pass

    def get_hostname_suggestion(self, LayerId: str) -> GetHostnameSuggestionResult:
        pass

    def grant_access(self, InstanceId: str, ValidForInMinutes: int=None) -> GrantAccessResult:
        pass

    def list_tags(self, ResourceArn: str, MaxResults: int=None, NextToken: str=None) -> ListTagsResult:
        pass

    def reboot_instance(self, InstanceId: str):
        pass

    def register_ecs_cluster(self, StackId: str, EcsClusterArn: str) -> RegisterEcsClusterResult:
        pass

    def register_elastic_ip(self, StackId: str, ElasticIp: str) -> RegisterElasticIpResult:
        pass

    def register_instance(self, StackId: str, Hostname: str=None, PublicIp: str=None, PrivateIp: str=None, RsaPublicKey: str=None, RsaPublicKeyFingerprint: str=None, InstanceIdentity: InstanceIdentity=None) -> RegisterInstanceResult:
        pass

    def register_rds_db_instance(self, DbPassword: str, DbUser: str, RdsDbInstanceArn: str, StackId: str):
        pass

    def register_volume(self, StackId: str, Ec2VolumeId: str=None) -> RegisterVolumeResult:
        pass

    def set_load_based_auto_scaling(self, LayerId: str, Enable: Boolean=None, UpScaling: AutoScalingThresholds=None, DownScaling: AutoScalingThresholds=None):
        pass

    def set_permission(self, IamUserArn: str, StackId: str, AllowSsh: Boolean=None, AllowSudo: Boolean=None, Level: str=None):
        pass

    def set_time_based_auto_scaling(self, InstanceId: str, AutoScalingSchedule: WeeklyAutoScalingSchedule=None):
        pass

    def start_instance(self, InstanceId: str):
        pass

    def start_stack(self, StackId: str):
        pass

    def stop_instance(self, InstanceId: str, Force: Boolean=None):
        pass

    def stop_stack(self, StackId: str):
        pass

    def tag_resource(self, Tags: Tags, ResourceArn: str):
        pass

    def unassign_instance(self, InstanceId: str):
        pass

    def unassign_volume(self, VolumeId: str):
        pass

    def untag_resource(self, TagKeys: List[TagKey], ResourceArn: str):
        pass

    def update_app(self, AppId: str, Name: str=None, Description: str=None, DataSources: List[DataSource]=None, Type: str=None, AppSource: Source=None, Domains: List[String]=None, EnableSsl: Boolean=None, SslConfiguration: SslConfiguration=None, Attributes: AppAttributes=None, Environment: List[EnvironmentVariable]=None):
        pass

    def update_elastic_ip(self, ElasticIp: str, Name: str=None):
        pass

    def update_instance(self, InstanceId: str, LayerIds: List[String]=None, InstanceType: str=None, AutoScalingType: str=None, Hostname: str=None, Os: str=None, AmiId: str=None, SshKeyName: str=None, Architecture: str=None, InstallUpdatesOnBoot: Boolean=None, EbsOptimized: Boolean=None, AgentVersion: str=None):
        pass

    def update_layer(self, LayerId: str, Name: str=None, Shortname: str=None, Attributes: LayerAttributes=None, CloudWatchLogsConfiguration: CloudWatchLogsConfiguration=None, CustomInstanceProfileArn: str=None, CustomJson: str=None, CustomSecurityGroupIds: List[String]=None, Packages: List[String]=None, VolumeConfigurations: List[VolumeConfiguration]=None, EnableAutoHealing: Boolean=None, AutoAssignElasticIps: Boolean=None, AutoAssignPublicIps: Boolean=None, CustomRecipes: Recipes=None, InstallUpdatesOnBoot: Boolean=None, UseEbsOptimizedInstances: Boolean=None, LifecycleEventConfiguration: LifecycleEventConfiguration=None):
        pass

    def update_my_user_profile(self, SshPublicKey: str=None):
        pass

    def update_rds_db_instance(self, RdsDbInstanceArn: str, DbUser: str=None, DbPassword: str=None):
        pass

    def update_stack(self, StackId: str, Name: str=None, Attributes: StackAttributes=None, ServiceRoleArn: str=None, DefaultInstanceProfileArn: str=None, DefaultOs: str=None, HostnameTheme: str=None, DefaultAvailabilityZone: str=None, DefaultSubnetId: str=None, CustomJson: str=None, ConfigurationManager: StackConfigurationManager=None, ChefConfiguration: ChefConfiguration=None, UseCustomCookbooks: Boolean=None, CustomCookbooksSource: Source=None, DefaultSshKeyName: str=None, DefaultRootDeviceType: str=None, UseOpsworksSecurityGroups: Boolean=None, AgentVersion: str=None):
        pass

    def update_user_profile(self, IamUserArn: str, SshUsername: str=None, SshPublicKey: str=None, AllowSelfManagement: Boolean=None):
        pass

    def update_volume(self, VolumeId: str, Name: str=None, MountPoint: str=None):
        pass


class OpsWorksCM(BaseClient):
    class AssociateNodeRequest(Mapping):
        pass

    class AssociateNodeResponse(Mapping):
        pass

    class EngineAttribute(Mapping):
        pass

    class CreateBackupRequest(Mapping):
        pass

    class CreateBackupResponse(Mapping):
        pass

    class CreateServerRequest(Mapping):
        pass

    class CreateServerResponse(Mapping):
        pass

    class Boolean(object):
        pass

    class String(object):
        pass

    class DeleteBackupRequest(Mapping):
        pass

    class DeleteBackupResponse(Mapping):
        pass

    class DeleteServerRequest(Mapping):
        pass

    class DeleteServerResponse(Mapping):
        pass

    class DescribeAccountAttributesRequest(Mapping):
        pass

    class DescribeAccountAttributesResponse(Mapping):
        pass

    class DescribeBackupsRequest(Mapping):
        pass

    class DescribeBackupsResponse(Mapping):
        pass

    class DescribeEventsRequest(Mapping):
        pass

    class DescribeEventsResponse(Mapping):
        pass

    class DescribeNodeAssociationStatusRequest(Mapping):
        pass

    class DescribeNodeAssociationStatusResponse(Mapping):
        pass

    class DescribeServersRequest(Mapping):
        pass

    class DescribeServersResponse(Mapping):
        pass

    class DisassociateNodeRequest(Mapping):
        pass

    class DisassociateNodeResponse(Mapping):
        pass

    class ExportServerEngineAttributeRequest(Mapping):
        pass

    class ExportServerEngineAttributeResponse(Mapping):
        pass

    class RestoreServerRequest(Mapping):
        pass

    class RestoreServerResponse(Mapping):
        pass

    class StartMaintenanceRequest(Mapping):
        pass

    class StartMaintenanceResponse(Mapping):
        pass

    class UpdateServerRequest(Mapping):
        pass

    class UpdateServerResponse(Mapping):
        pass

    class UpdateServerEngineAttributesRequest(Mapping):
        pass

    class UpdateServerEngineAttributesResponse(Mapping):
        pass

    def associate_node(self, EngineAttributes: List[EngineAttribute], NodeName: str, ServerName: str) -> AssociateNodeResponse:
        pass

    def create_backup(self, ServerName: str, Description: str=None) -> CreateBackupResponse:
        pass

    def create_server(self, ServiceRoleArn: str, InstanceType: str, InstanceProfileArn: str, ServerName: str, AssociatePublicIpAddress: Boolean=None, DisableAutomatedBackup: Boolean=None, Engine: str=None, EngineModel: str=None, EngineVersion: str=None, EngineAttributes: List[EngineAttribute]=None, BackupRetentionCount: int=None, KeyPair: str=None, PreferredMaintenanceWindow: str=None, PreferredBackupWindow: str=None, SecurityGroupIds: List[String]=None, SubnetIds: List[String]=None, BackupId: str=None) -> CreateServerResponse:
        pass

    def delete_backup(self, BackupId: str) -> DeleteBackupResponse:
        pass

    def delete_server(self, ServerName: str) -> DeleteServerResponse:
        pass

    def describe_account_attributes(self) -> DescribeAccountAttributesResponse:
        pass

    def describe_backups(self, BackupId: str=None, ServerName: str=None, NextToken: str=None, MaxResults: int=None) -> DescribeBackupsResponse:
        pass

    def describe_events(self, ServerName: str, NextToken: str=None, MaxResults: int=None) -> DescribeEventsResponse:
        pass

    def describe_node_association_status(self, ServerName: str, NodeAssociationStatusToken: str) -> DescribeNodeAssociationStatusResponse:
        pass

    def describe_servers(self, ServerName: str=None, NextToken: str=None, MaxResults: int=None) -> DescribeServersResponse:
        pass

    def disassociate_node(self, NodeName: str, ServerName: str, EngineAttributes: List[EngineAttribute]=None) -> DisassociateNodeResponse:
        pass

    def export_server_engine_attribute(self, ServerName: str, ExportAttributeName: str, InputAttributes: List[EngineAttribute]=None) -> ExportServerEngineAttributeResponse:
        pass

    def restore_server(self, ServerName: str, BackupId: str, InstanceType: str=None, KeyPair: str=None) -> RestoreServerResponse:
        pass

    def start_maintenance(self, ServerName: str, EngineAttributes: List[EngineAttribute]=None) -> StartMaintenanceResponse:
        pass

    def update_server(self, ServerName: str, DisableAutomatedBackup: Boolean=None, BackupRetentionCount: int=None, PreferredMaintenanceWindow: str=None, PreferredBackupWindow: str=None) -> UpdateServerResponse:
        pass

    def update_server_engine_attributes(self, AttributeName: str, ServerName: str, AttributeValue: str=None) -> UpdateServerEngineAttributesResponse:
        pass


class Organizations(BaseClient):
    class AcceptHandshakeRequest(Mapping):
        pass

    class AcceptHandshakeResponse(Mapping):
        pass

    class AttachPolicyRequest(Mapping):
        pass

    class CancelHandshakeRequest(Mapping):
        pass

    class CancelHandshakeResponse(Mapping):
        pass

    class CreateAccountRequest(Mapping):
        pass

    class CreateAccountResponse(Mapping):
        pass

    class CreateOrganizationRequest(Mapping):
        pass

    class CreateOrganizationResponse(Mapping):
        pass

    class CreateOrganizationalUnitRequest(Mapping):
        pass

    class CreateOrganizationalUnitResponse(Mapping):
        pass

    class CreatePolicyRequest(Mapping):
        pass

    class CreatePolicyResponse(Mapping):
        pass

    class DeclineHandshakeRequest(Mapping):
        pass

    class DeclineHandshakeResponse(Mapping):
        pass

    class DeleteOrganizationalUnitRequest(Mapping):
        pass

    class DeletePolicyRequest(Mapping):
        pass

    class DescribeAccountRequest(Mapping):
        pass

    class DescribeAccountResponse(Mapping):
        pass

    class DescribeCreateAccountStatusRequest(Mapping):
        pass

    class DescribeCreateAccountStatusResponse(Mapping):
        pass

    class DescribeHandshakeRequest(Mapping):
        pass

    class DescribeHandshakeResponse(Mapping):
        pass

    class DescribeOrganizationResponse(Mapping):
        pass

    class DescribeOrganizationalUnitRequest(Mapping):
        pass

    class DescribeOrganizationalUnitResponse(Mapping):
        pass

    class DescribePolicyRequest(Mapping):
        pass

    class DescribePolicyResponse(Mapping):
        pass

    class DetachPolicyRequest(Mapping):
        pass

    class DisableAWSServiceAccessRequest(Mapping):
        pass

    class DisablePolicyTypeRequest(Mapping):
        pass

    class DisablePolicyTypeResponse(Mapping):
        pass

    class EnableAWSServiceAccessRequest(Mapping):
        pass

    class EnableAllFeaturesRequest(Mapping):
        pass

    class EnableAllFeaturesResponse(Mapping):
        pass

    class EnablePolicyTypeRequest(Mapping):
        pass

    class EnablePolicyTypeResponse(Mapping):
        pass

    class InviteAccountToOrganizationRequest(Mapping):
        pass

    class InviteAccountToOrganizationResponse(Mapping):
        pass

    class HandshakeParty(Mapping):
        pass

    class ListAWSServiceAccessForOrganizationRequest(Mapping):
        pass

    class ListAWSServiceAccessForOrganizationResponse(Mapping):
        pass

    class ListAccountsRequest(Mapping):
        pass

    class ListAccountsResponse(Mapping):
        pass

    class ListAccountsForParentRequest(Mapping):
        pass

    class ListAccountsForParentResponse(Mapping):
        pass

    class ListChildrenRequest(Mapping):
        pass

    class ListChildrenResponse(Mapping):
        pass

    class ListCreateAccountStatusRequest(Mapping):
        pass

    class ListCreateAccountStatusResponse(Mapping):
        pass

    class CreateAccountState(object):
        pass

    class ListHandshakesForAccountRequest(Mapping):
        pass

    class ListHandshakesForAccountResponse(Mapping):
        pass

    class HandshakeFilter(Mapping):
        pass

    class ListHandshakesForOrganizationRequest(Mapping):
        pass

    class ListHandshakesForOrganizationResponse(Mapping):
        pass

    class ListOrganizationalUnitsForParentRequest(Mapping):
        pass

    class ListOrganizationalUnitsForParentResponse(Mapping):
        pass

    class ListParentsRequest(Mapping):
        pass

    class ListParentsResponse(Mapping):
        pass

    class ListPoliciesRequest(Mapping):
        pass

    class ListPoliciesResponse(Mapping):
        pass

    class ListPoliciesForTargetRequest(Mapping):
        pass

    class ListPoliciesForTargetResponse(Mapping):
        pass

    class ListRootsRequest(Mapping):
        pass

    class ListRootsResponse(Mapping):
        pass

    class ListTargetsForPolicyRequest(Mapping):
        pass

    class ListTargetsForPolicyResponse(Mapping):
        pass

    class MoveAccountRequest(Mapping):
        pass

    class RemoveAccountFromOrganizationRequest(Mapping):
        pass

    class UpdateOrganizationalUnitRequest(Mapping):
        pass

    class UpdateOrganizationalUnitResponse(Mapping):
        pass

    class UpdatePolicyRequest(Mapping):
        pass

    class UpdatePolicyResponse(Mapping):
        pass

    def accept_handshake(self, HandshakeId: str) -> AcceptHandshakeResponse:
        pass

    def attach_policy(self, TargetId: str, PolicyId: str):
        pass

    def cancel_handshake(self, HandshakeId: str) -> CancelHandshakeResponse:
        pass

    def create_account(self, AccountName: str, Email: str, RoleName: str=None, IamUserAccessToBilling: str=None) -> CreateAccountResponse:
        pass

    def create_organization(self, FeatureSet: str=None) -> CreateOrganizationResponse:
        pass

    def create_organizational_unit(self, Name: str, ParentId: str) -> CreateOrganizationalUnitResponse:
        pass

    def create_policy(self, Type: str, Name: str, Description: str, Content: str) -> CreatePolicyResponse:
        pass

    def decline_handshake(self, HandshakeId: str) -> DeclineHandshakeResponse:
        pass

    def delete_organization(self):
        pass

    def delete_organizational_unit(self, OrganizationalUnitId: str):
        pass

    def delete_policy(self, PolicyId: str):
        pass

    def describe_account(self, AccountId: str) -> DescribeAccountResponse:
        pass

    def describe_create_account_status(self, CreateAccountRequestId: str) -> DescribeCreateAccountStatusResponse:
        pass

    def describe_handshake(self, HandshakeId: str) -> DescribeHandshakeResponse:
        pass

    def describe_organization(self) -> DescribeOrganizationResponse:
        pass

    def describe_organizational_unit(self, OrganizationalUnitId: str) -> DescribeOrganizationalUnitResponse:
        pass

    def describe_policy(self, PolicyId: str) -> DescribePolicyResponse:
        pass

    def detach_policy(self, TargetId: str, PolicyId: str):
        pass

    def disable_aws_service_access(self, ServicePrincipal: str):
        pass

    def disable_policy_type(self, PolicyType: str, RootId: str) -> DisablePolicyTypeResponse:
        pass

    def enable_aws_service_access(self, ServicePrincipal: str):
        pass

    def enable_all_features(self) -> EnableAllFeaturesResponse:
        pass

    def enable_policy_type(self, PolicyType: str, RootId: str) -> EnablePolicyTypeResponse:
        pass

    def invite_account_to_organization(self, Target: HandshakeParty, Notes: str=None) -> InviteAccountToOrganizationResponse:
        pass

    def leave_organization(self):
        pass

    def list_aws_service_access_for_organization(self, NextToken: str=None, MaxResults: int=None) -> ListAWSServiceAccessForOrganizationResponse:
        pass

    def list_accounts(self, NextToken: str=None, MaxResults: int=None) -> ListAccountsResponse:
        pass

    def list_accounts_for_parent(self, ParentId: str, NextToken: str=None, MaxResults: int=None) -> ListAccountsForParentResponse:
        pass

    def list_children(self, ChildType: str, ParentId: str, NextToken: str=None, MaxResults: int=None) -> ListChildrenResponse:
        pass

    def list_create_account_status(self, States: List[CreateAccountState]=None, NextToken: str=None, MaxResults: int=None) -> ListCreateAccountStatusResponse:
        pass

    def list_handshakes_for_account(self, Filter: HandshakeFilter=None, NextToken: str=None, MaxResults: int=None) -> ListHandshakesForAccountResponse:
        pass

    def list_handshakes_for_organization(self, Filter: HandshakeFilter=None, NextToken: str=None, MaxResults: int=None) -> ListHandshakesForOrganizationResponse:
        pass

    def list_organizational_units_for_parent(self, ParentId: str, NextToken: str=None, MaxResults: int=None) -> ListOrganizationalUnitsForParentResponse:
        pass

    def list_parents(self, ChildId: str, NextToken: str=None, MaxResults: int=None) -> ListParentsResponse:
        pass

    def list_policies(self, Filter: str, NextToken: str=None, MaxResults: int=None) -> ListPoliciesResponse:
        pass

    def list_policies_for_target(self, Filter: str, TargetId: str, NextToken: str=None, MaxResults: int=None) -> ListPoliciesForTargetResponse:
        pass

    def list_roots(self, NextToken: str=None, MaxResults: int=None) -> ListRootsResponse:
        pass

    def list_targets_for_policy(self, PolicyId: str, NextToken: str=None, MaxResults: int=None) -> ListTargetsForPolicyResponse:
        pass

    def move_account(self, DestinationParentId: str, SourceParentId: str, AccountId: str):
        pass

    def remove_account_from_organization(self, AccountId: str):
        pass

    def update_organizational_unit(self, OrganizationalUnitId: str, Name: str=None) -> UpdateOrganizationalUnitResponse:
        pass

    def update_policy(self, PolicyId: str, Name: str=None, Description: str=None, Content: str=None) -> UpdatePolicyResponse:
        pass


class PI(BaseClient):
    class DescribeDimensionKeysRequest(Mapping):
        pass

    class DescribeDimensionKeysResponse(Mapping):
        pass

    class ISOTimestamp(object):
        pass

    class DimensionGroup(Mapping):
        pass

    class MetricQueryFilterMap(object):
        pass

    class GetResourceMetricsRequest(Mapping):
        pass

    class GetResourceMetricsResponse(Mapping):
        pass

    class MetricQuery(Mapping):
        pass

    def describe_dimension_keys(self, GroupBy: DimensionGroup, Metric: str, EndTime: ISOTimestamp, StartTime: ISOTimestamp, Identifier: str, ServiceType: str, PeriodInSeconds: int=None, PartitionBy: DimensionGroup=None, Filter: MetricQueryFilterMap=None, MaxResults: int=None, NextToken: str=None) -> DescribeDimensionKeysResponse:
        pass

    def get_resource_metrics(self, EndTime: ISOTimestamp, StartTime: ISOTimestamp, MetricQueries: List[MetricQuery], Identifier: str, ServiceType: str, PeriodInSeconds: int=None, MaxResults: int=None, NextToken: str=None) -> GetResourceMetricsResponse:
        pass


class Pinpoint(BaseClient):
    class CreateAppRequest(Mapping):
        pass

    class CreateAppResponse(Mapping):
        pass

    class CreateApplicationRequest(Mapping):
        pass

    class CreateCampaignRequest(Mapping):
        pass

    class CreateCampaignResponse(Mapping):
        pass

    class WriteCampaignRequest(Mapping):
        pass

    class CreateExportJobRequest(Mapping):
        pass

    class CreateExportJobResponse(Mapping):
        pass

    class ExportJobRequest(Mapping):
        pass

    class CreateImportJobRequest(Mapping):
        pass

    class CreateImportJobResponse(Mapping):
        pass

    class ImportJobRequest(Mapping):
        pass

    class CreateSegmentRequest(Mapping):
        pass

    class CreateSegmentResponse(Mapping):
        pass

    class WriteSegmentRequest(Mapping):
        pass

    class DeleteAdmChannelRequest(Mapping):
        pass

    class DeleteAdmChannelResponse(Mapping):
        pass

    class DeleteApnsChannelRequest(Mapping):
        pass

    class DeleteApnsChannelResponse(Mapping):
        pass

    class DeleteApnsSandboxChannelRequest(Mapping):
        pass

    class DeleteApnsSandboxChannelResponse(Mapping):
        pass

    class DeleteApnsVoipChannelRequest(Mapping):
        pass

    class DeleteApnsVoipChannelResponse(Mapping):
        pass

    class DeleteApnsVoipSandboxChannelRequest(Mapping):
        pass

    class DeleteApnsVoipSandboxChannelResponse(Mapping):
        pass

    class DeleteAppRequest(Mapping):
        pass

    class DeleteAppResponse(Mapping):
        pass

    class DeleteBaiduChannelRequest(Mapping):
        pass

    class DeleteBaiduChannelResponse(Mapping):
        pass

    class DeleteCampaignRequest(Mapping):
        pass

    class DeleteCampaignResponse(Mapping):
        pass

    class DeleteEmailChannelRequest(Mapping):
        pass

    class DeleteEmailChannelResponse(Mapping):
        pass

    class DeleteEndpointRequest(Mapping):
        pass

    class DeleteEndpointResponse(Mapping):
        pass

    class DeleteEventStreamRequest(Mapping):
        pass

    class DeleteEventStreamResponse(Mapping):
        pass

    class DeleteGcmChannelRequest(Mapping):
        pass

    class DeleteGcmChannelResponse(Mapping):
        pass

    class DeleteSegmentRequest(Mapping):
        pass

    class DeleteSegmentResponse(Mapping):
        pass

    class DeleteSmsChannelRequest(Mapping):
        pass

    class DeleteSmsChannelResponse(Mapping):
        pass

    class DeleteUserEndpointsRequest(Mapping):
        pass

    class DeleteUserEndpointsResponse(Mapping):
        pass

    class DeleteVoiceChannelRequest(Mapping):
        pass

    class DeleteVoiceChannelResponse(Mapping):
        pass

    class GetAdmChannelRequest(Mapping):
        pass

    class GetAdmChannelResponse(Mapping):
        pass

    class GetApnsChannelRequest(Mapping):
        pass

    class GetApnsChannelResponse(Mapping):
        pass

    class GetApnsSandboxChannelRequest(Mapping):
        pass

    class GetApnsSandboxChannelResponse(Mapping):
        pass

    class GetApnsVoipChannelRequest(Mapping):
        pass

    class GetApnsVoipChannelResponse(Mapping):
        pass

    class GetApnsVoipSandboxChannelRequest(Mapping):
        pass

    class GetApnsVoipSandboxChannelResponse(Mapping):
        pass

    class GetAppRequest(Mapping):
        pass

    class GetAppResponse(Mapping):
        pass

    class GetApplicationSettingsRequest(Mapping):
        pass

    class GetApplicationSettingsResponse(Mapping):
        pass

    class GetAppsRequest(Mapping):
        pass

    class GetAppsResponse(Mapping):
        pass

    class GetBaiduChannelRequest(Mapping):
        pass

    class GetBaiduChannelResponse(Mapping):
        pass

    class GetCampaignRequest(Mapping):
        pass

    class GetCampaignResponse(Mapping):
        pass

    class GetCampaignActivitiesRequest(Mapping):
        pass

    class GetCampaignActivitiesResponse(Mapping):
        pass

    class GetCampaignVersionRequest(Mapping):
        pass

    class GetCampaignVersionResponse(Mapping):
        pass

    class GetCampaignVersionsRequest(Mapping):
        pass

    class GetCampaignVersionsResponse(Mapping):
        pass

    class GetCampaignsRequest(Mapping):
        pass

    class GetCampaignsResponse(Mapping):
        pass

    class GetChannelsRequest(Mapping):
        pass

    class GetChannelsResponse(Mapping):
        pass

    class GetEmailChannelRequest(Mapping):
        pass

    class GetEmailChannelResponse(Mapping):
        pass

    class GetEndpointRequest(Mapping):
        pass

    class GetEndpointResponse(Mapping):
        pass

    class GetEventStreamRequest(Mapping):
        pass

    class GetEventStreamResponse(Mapping):
        pass

    class GetExportJobRequest(Mapping):
        pass

    class GetExportJobResponse(Mapping):
        pass

    class GetExportJobsRequest(Mapping):
        pass

    class GetExportJobsResponse(Mapping):
        pass

    class GetGcmChannelRequest(Mapping):
        pass

    class GetGcmChannelResponse(Mapping):
        pass

    class GetImportJobRequest(Mapping):
        pass

    class GetImportJobResponse(Mapping):
        pass

    class GetImportJobsRequest(Mapping):
        pass

    class GetImportJobsResponse(Mapping):
        pass

    class GetSegmentRequest(Mapping):
        pass

    class GetSegmentResponse(Mapping):
        pass

    class GetSegmentExportJobsRequest(Mapping):
        pass

    class GetSegmentExportJobsResponse(Mapping):
        pass

    class GetSegmentImportJobsRequest(Mapping):
        pass

    class GetSegmentImportJobsResponse(Mapping):
        pass

    class GetSegmentVersionRequest(Mapping):
        pass

    class GetSegmentVersionResponse(Mapping):
        pass

    class GetSegmentVersionsRequest(Mapping):
        pass

    class GetSegmentVersionsResponse(Mapping):
        pass

    class GetSegmentsRequest(Mapping):
        pass

    class GetSegmentsResponse(Mapping):
        pass

    class GetSmsChannelRequest(Mapping):
        pass

    class GetSmsChannelResponse(Mapping):
        pass

    class GetUserEndpointsRequest(Mapping):
        pass

    class GetUserEndpointsResponse(Mapping):
        pass

    class GetVoiceChannelRequest(Mapping):
        pass

    class GetVoiceChannelResponse(Mapping):
        pass

    class PhoneNumberValidateRequest(Mapping):
        pass

    class PhoneNumberValidateResponse(Mapping):
        pass

    class NumberValidateRequest(Mapping):
        pass

    class PutEventStreamRequest(Mapping):
        pass

    class PutEventStreamResponse(Mapping):
        pass

    class WriteEventStream(Mapping):
        pass

    class PutEventsRequest(Mapping):
        pass

    class PutEventsResponse(Mapping):
        pass

    class EventsRequest(Mapping):
        pass

    class RemoveAttributesRequest(Mapping):
        pass

    class RemoveAttributesResponse(Mapping):
        pass

    class UpdateAttributesRequest(Mapping):
        pass

    class SendMessagesRequest(Mapping):
        pass

    class SendMessagesResponse(Mapping):
        pass

    class MessageRequest(Mapping):
        pass

    class SendUsersMessagesRequest(Mapping):
        pass

    class SendUsersMessagesResponse(Mapping):
        pass

    class SendUsersMessageRequest(Mapping):
        pass

    class UpdateAdmChannelRequest(Mapping):
        pass

    class UpdateAdmChannelResponse(Mapping):
        pass

    class ADMChannelRequest(Mapping):
        pass

    class UpdateApnsChannelRequest(Mapping):
        pass

    class UpdateApnsChannelResponse(Mapping):
        pass

    class APNSChannelRequest(Mapping):
        pass

    class UpdateApnsSandboxChannelRequest(Mapping):
        pass

    class UpdateApnsSandboxChannelResponse(Mapping):
        pass

    class APNSSandboxChannelRequest(Mapping):
        pass

    class UpdateApnsVoipChannelRequest(Mapping):
        pass

    class UpdateApnsVoipChannelResponse(Mapping):
        pass

    class APNSVoipChannelRequest(Mapping):
        pass

    class UpdateApnsVoipSandboxChannelRequest(Mapping):
        pass

    class UpdateApnsVoipSandboxChannelResponse(Mapping):
        pass

    class APNSVoipSandboxChannelRequest(Mapping):
        pass

    class UpdateApplicationSettingsRequest(Mapping):
        pass

    class UpdateApplicationSettingsResponse(Mapping):
        pass

    class WriteApplicationSettingsRequest(Mapping):
        pass

    class UpdateBaiduChannelRequest(Mapping):
        pass

    class UpdateBaiduChannelResponse(Mapping):
        pass

    class BaiduChannelRequest(Mapping):
        pass

    class UpdateCampaignRequest(Mapping):
        pass

    class UpdateCampaignResponse(Mapping):
        pass

    class UpdateEmailChannelRequest(Mapping):
        pass

    class UpdateEmailChannelResponse(Mapping):
        pass

    class EmailChannelRequest(Mapping):
        pass

    class UpdateEndpointRequest(Mapping):
        pass

    class UpdateEndpointResponse(Mapping):
        pass

    class EndpointRequest(Mapping):
        pass

    class UpdateEndpointsBatchRequest(Mapping):
        pass

    class UpdateEndpointsBatchResponse(Mapping):
        pass

    class EndpointBatchRequest(Mapping):
        pass

    class UpdateGcmChannelRequest(Mapping):
        pass

    class UpdateGcmChannelResponse(Mapping):
        pass

    class GCMChannelRequest(Mapping):
        pass

    class UpdateSegmentRequest(Mapping):
        pass

    class UpdateSegmentResponse(Mapping):
        pass

    class UpdateSmsChannelRequest(Mapping):
        pass

    class UpdateSmsChannelResponse(Mapping):
        pass

    class SMSChannelRequest(Mapping):
        pass

    class UpdateVoiceChannelRequest(Mapping):
        pass

    class UpdateVoiceChannelResponse(Mapping):
        pass

    class VoiceChannelRequest(Mapping):
        pass

    def create_app(self, CreateApplicationRequest: CreateApplicationRequest) -> CreateAppResponse:
        pass

    def create_campaign(self, WriteCampaignRequest: WriteCampaignRequest, ApplicationId: str) -> CreateCampaignResponse:
        pass

    def create_export_job(self, ExportJobRequest: ExportJobRequest, ApplicationId: str) -> CreateExportJobResponse:
        pass

    def create_import_job(self, ImportJobRequest: ImportJobRequest, ApplicationId: str) -> CreateImportJobResponse:
        pass

    def create_segment(self, WriteSegmentRequest: WriteSegmentRequest, ApplicationId: str) -> CreateSegmentResponse:
        pass

    def delete_adm_channel(self, ApplicationId: str) -> DeleteAdmChannelResponse:
        pass

    def delete_apns_channel(self, ApplicationId: str) -> DeleteApnsChannelResponse:
        pass

    def delete_apns_sandbox_channel(self, ApplicationId: str) -> DeleteApnsSandboxChannelResponse:
        pass

    def delete_apns_voip_channel(self, ApplicationId: str) -> DeleteApnsVoipChannelResponse:
        pass

    def delete_apns_voip_sandbox_channel(self, ApplicationId: str) -> DeleteApnsVoipSandboxChannelResponse:
        pass

    def delete_app(self, ApplicationId: str) -> DeleteAppResponse:
        pass

    def delete_baidu_channel(self, ApplicationId: str) -> DeleteBaiduChannelResponse:
        pass

    def delete_campaign(self, CampaignId: str, ApplicationId: str) -> DeleteCampaignResponse:
        pass

    def delete_email_channel(self, ApplicationId: str) -> DeleteEmailChannelResponse:
        pass

    def delete_endpoint(self, EndpointId: str, ApplicationId: str) -> DeleteEndpointResponse:
        pass

    def delete_event_stream(self, ApplicationId: str) -> DeleteEventStreamResponse:
        pass

    def delete_gcm_channel(self, ApplicationId: str) -> DeleteGcmChannelResponse:
        pass

    def delete_segment(self, SegmentId: str, ApplicationId: str) -> DeleteSegmentResponse:
        pass

    def delete_sms_channel(self, ApplicationId: str) -> DeleteSmsChannelResponse:
        pass

    def delete_user_endpoints(self, UserId: str, ApplicationId: str) -> DeleteUserEndpointsResponse:
        pass

    def delete_voice_channel(self, ApplicationId: str) -> DeleteVoiceChannelResponse:
        pass

    def get_adm_channel(self, ApplicationId: str) -> GetAdmChannelResponse:
        pass

    def get_apns_channel(self, ApplicationId: str) -> GetApnsChannelResponse:
        pass

    def get_apns_sandbox_channel(self, ApplicationId: str) -> GetApnsSandboxChannelResponse:
        pass

    def get_apns_voip_channel(self, ApplicationId: str) -> GetApnsVoipChannelResponse:
        pass

    def get_apns_voip_sandbox_channel(self, ApplicationId: str) -> GetApnsVoipSandboxChannelResponse:
        pass

    def get_app(self, ApplicationId: str) -> GetAppResponse:
        pass

    def get_application_settings(self, ApplicationId: str) -> GetApplicationSettingsResponse:
        pass

    def get_apps(self, PageSize: str=None, Token: str=None) -> GetAppsResponse:
        pass

    def get_baidu_channel(self, ApplicationId: str) -> GetBaiduChannelResponse:
        pass

    def get_campaign(self, CampaignId: str, ApplicationId: str) -> GetCampaignResponse:
        pass

    def get_campaign_activities(self, CampaignId: str, ApplicationId: str, PageSize: str=None, Token: str=None) -> GetCampaignActivitiesResponse:
        pass

    def get_campaign_version(self, Version: str, CampaignId: str, ApplicationId: str) -> GetCampaignVersionResponse:
        pass

    def get_campaign_versions(self, CampaignId: str, ApplicationId: str, PageSize: str=None, Token: str=None) -> GetCampaignVersionsResponse:
        pass

    def get_campaigns(self, ApplicationId: str, PageSize: str=None, Token: str=None) -> GetCampaignsResponse:
        pass

    def get_channels(self, ApplicationId: str) -> GetChannelsResponse:
        pass

    def get_email_channel(self, ApplicationId: str) -> GetEmailChannelResponse:
        pass

    def get_endpoint(self, EndpointId: str, ApplicationId: str) -> GetEndpointResponse:
        pass

    def get_event_stream(self, ApplicationId: str) -> GetEventStreamResponse:
        pass

    def get_export_job(self, JobId: str, ApplicationId: str) -> GetExportJobResponse:
        pass

    def get_export_jobs(self, ApplicationId: str, PageSize: str=None, Token: str=None) -> GetExportJobsResponse:
        pass

    def get_gcm_channel(self, ApplicationId: str) -> GetGcmChannelResponse:
        pass

    def get_import_job(self, JobId: str, ApplicationId: str) -> GetImportJobResponse:
        pass

    def get_import_jobs(self, ApplicationId: str, PageSize: str=None, Token: str=None) -> GetImportJobsResponse:
        pass

    def get_segment(self, SegmentId: str, ApplicationId: str) -> GetSegmentResponse:
        pass

    def get_segment_export_jobs(self, SegmentId: str, ApplicationId: str, PageSize: str=None, Token: str=None) -> GetSegmentExportJobsResponse:
        pass

    def get_segment_import_jobs(self, SegmentId: str, ApplicationId: str, PageSize: str=None, Token: str=None) -> GetSegmentImportJobsResponse:
        pass

    def get_segment_version(self, Version: str, SegmentId: str, ApplicationId: str) -> GetSegmentVersionResponse:
        pass

    def get_segment_versions(self, SegmentId: str, ApplicationId: str, PageSize: str=None, Token: str=None) -> GetSegmentVersionsResponse:
        pass

    def get_segments(self, ApplicationId: str, PageSize: str=None, Token: str=None) -> GetSegmentsResponse:
        pass

    def get_sms_channel(self, ApplicationId: str) -> GetSmsChannelResponse:
        pass

    def get_user_endpoints(self, UserId: str, ApplicationId: str) -> GetUserEndpointsResponse:
        pass

    def get_voice_channel(self, ApplicationId: str) -> GetVoiceChannelResponse:
        pass

    def phone_number_validate(self, NumberValidateRequest: NumberValidateRequest) -> PhoneNumberValidateResponse:
        pass

    def put_event_stream(self, WriteEventStream: WriteEventStream, ApplicationId: str) -> PutEventStreamResponse:
        pass

    def put_events(self, EventsRequest: EventsRequest, ApplicationId: str) -> PutEventsResponse:
        pass

    def remove_attributes(self, UpdateAttributesRequest: UpdateAttributesRequest, AttributeType: str, ApplicationId: str) -> RemoveAttributesResponse:
        pass

    def send_messages(self, MessageRequest: MessageRequest, ApplicationId: str) -> SendMessagesResponse:
        pass

    def send_users_messages(self, SendUsersMessageRequest: SendUsersMessageRequest, ApplicationId: str) -> SendUsersMessagesResponse:
        pass

    def update_adm_channel(self, ApplicationId: str, ADMChannelRequest: ADMChannelRequest) -> UpdateAdmChannelResponse:
        pass

    def update_apns_channel(self, ApplicationId: str, APNSChannelRequest: APNSChannelRequest) -> UpdateApnsChannelResponse:
        pass

    def update_apns_sandbox_channel(self, ApplicationId: str, APNSSandboxChannelRequest: APNSSandboxChannelRequest) -> UpdateApnsSandboxChannelResponse:
        pass

    def update_apns_voip_channel(self, ApplicationId: str, APNSVoipChannelRequest: APNSVoipChannelRequest) -> UpdateApnsVoipChannelResponse:
        pass

    def update_apns_voip_sandbox_channel(self, ApplicationId: str, APNSVoipSandboxChannelRequest: APNSVoipSandboxChannelRequest) -> UpdateApnsVoipSandboxChannelResponse:
        pass

    def update_application_settings(self, WriteApplicationSettingsRequest: WriteApplicationSettingsRequest, ApplicationId: str) -> UpdateApplicationSettingsResponse:
        pass

    def update_baidu_channel(self, BaiduChannelRequest: BaiduChannelRequest, ApplicationId: str) -> UpdateBaiduChannelResponse:
        pass

    def update_campaign(self, WriteCampaignRequest: WriteCampaignRequest, CampaignId: str, ApplicationId: str) -> UpdateCampaignResponse:
        pass

    def update_email_channel(self, EmailChannelRequest: EmailChannelRequest, ApplicationId: str) -> UpdateEmailChannelResponse:
        pass

    def update_endpoint(self, EndpointRequest: EndpointRequest, EndpointId: str, ApplicationId: str) -> UpdateEndpointResponse:
        pass

    def update_endpoints_batch(self, EndpointBatchRequest: EndpointBatchRequest, ApplicationId: str) -> UpdateEndpointsBatchResponse:
        pass

    def update_gcm_channel(self, GCMChannelRequest: GCMChannelRequest, ApplicationId: str) -> UpdateGcmChannelResponse:
        pass

    def update_segment(self, WriteSegmentRequest: WriteSegmentRequest, SegmentId: str, ApplicationId: str) -> UpdateSegmentResponse:
        pass

    def update_sms_channel(self, SMSChannelRequest: SMSChannelRequest, ApplicationId: str) -> UpdateSmsChannelResponse:
        pass

    def update_voice_channel(self, VoiceChannelRequest: VoiceChannelRequest, ApplicationId: str) -> UpdateVoiceChannelResponse:
        pass


class PinpointEmail(BaseClient):
    class CreateConfigurationSetRequest(Mapping):
        pass

    class CreateConfigurationSetResponse(Mapping):
        pass

    class TrackingOptions(Mapping):
        pass

    class DeliveryOptions(Mapping):
        pass

    class ReputationOptions(Mapping):
        pass

    class SendingOptions(Mapping):
        pass

    class CreateConfigurationSetEventDestinationRequest(Mapping):
        pass

    class CreateConfigurationSetEventDestinationResponse(Mapping):
        pass

    class EventDestinationDefinition(Mapping):
        pass

    class CreateDedicatedIpPoolRequest(Mapping):
        pass

    class CreateDedicatedIpPoolResponse(Mapping):
        pass

    class CreateDeliverabilityTestReportRequest(Mapping):
        pass

    class CreateDeliverabilityTestReportResponse(Mapping):
        pass

    class EmailContent(Mapping):
        pass

    class CreateEmailIdentityRequest(Mapping):
        pass

    class CreateEmailIdentityResponse(Mapping):
        pass

    class DeleteConfigurationSetRequest(Mapping):
        pass

    class DeleteConfigurationSetResponse(Mapping):
        pass

    class DeleteConfigurationSetEventDestinationRequest(Mapping):
        pass

    class DeleteConfigurationSetEventDestinationResponse(Mapping):
        pass

    class DeleteDedicatedIpPoolRequest(Mapping):
        pass

    class DeleteDedicatedIpPoolResponse(Mapping):
        pass

    class DeleteEmailIdentityRequest(Mapping):
        pass

    class DeleteEmailIdentityResponse(Mapping):
        pass

    class GetAccountRequest(Mapping):
        pass

    class GetAccountResponse(Mapping):
        pass

    class GetBlacklistReportsRequest(Mapping):
        pass

    class GetBlacklistReportsResponse(Mapping):
        pass

    class BlacklistItemName(object):
        pass

    class GetConfigurationSetRequest(Mapping):
        pass

    class GetConfigurationSetResponse(Mapping):
        pass

    class GetConfigurationSetEventDestinationsRequest(Mapping):
        pass

    class GetConfigurationSetEventDestinationsResponse(Mapping):
        pass

    class GetDedicatedIpRequest(Mapping):
        pass

    class GetDedicatedIpResponse(Mapping):
        pass

    class GetDedicatedIpsRequest(Mapping):
        pass

    class GetDedicatedIpsResponse(Mapping):
        pass

    class GetDeliverabilityDashboardOptionsRequest(Mapping):
        pass

    class GetDeliverabilityDashboardOptionsResponse(Mapping):
        pass

    class GetDeliverabilityTestReportRequest(Mapping):
        pass

    class GetDeliverabilityTestReportResponse(Mapping):
        pass

    class GetDomainStatisticsReportRequest(Mapping):
        pass

    class GetDomainStatisticsReportResponse(Mapping):
        pass

    class Timestamp(object):
        pass

    class GetEmailIdentityRequest(Mapping):
        pass

    class GetEmailIdentityResponse(Mapping):
        pass

    class ListConfigurationSetsRequest(Mapping):
        pass

    class ListConfigurationSetsResponse(Mapping):
        pass

    class ListDedicatedIpPoolsRequest(Mapping):
        pass

    class ListDedicatedIpPoolsResponse(Mapping):
        pass

    class ListDeliverabilityTestReportsRequest(Mapping):
        pass

    class ListDeliverabilityTestReportsResponse(Mapping):
        pass

    class ListEmailIdentitiesRequest(Mapping):
        pass

    class ListEmailIdentitiesResponse(Mapping):
        pass

    class PutAccountDedicatedIpWarmupAttributesRequest(Mapping):
        pass

    class PutAccountDedicatedIpWarmupAttributesResponse(Mapping):
        pass

    class Enabled(object):
        pass

    class PutAccountSendingAttributesRequest(Mapping):
        pass

    class PutAccountSendingAttributesResponse(Mapping):
        pass

    class PutConfigurationSetDeliveryOptionsRequest(Mapping):
        pass

    class PutConfigurationSetDeliveryOptionsResponse(Mapping):
        pass

    class PutConfigurationSetReputationOptionsRequest(Mapping):
        pass

    class PutConfigurationSetReputationOptionsResponse(Mapping):
        pass

    class PutConfigurationSetSendingOptionsRequest(Mapping):
        pass

    class PutConfigurationSetSendingOptionsResponse(Mapping):
        pass

    class PutConfigurationSetTrackingOptionsRequest(Mapping):
        pass

    class PutConfigurationSetTrackingOptionsResponse(Mapping):
        pass

    class PutDedicatedIpInPoolRequest(Mapping):
        pass

    class PutDedicatedIpInPoolResponse(Mapping):
        pass

    class PutDedicatedIpWarmupAttributesRequest(Mapping):
        pass

    class PutDedicatedIpWarmupAttributesResponse(Mapping):
        pass

    class PutDeliverabilityDashboardOptionRequest(Mapping):
        pass

    class PutDeliverabilityDashboardOptionResponse(Mapping):
        pass

    class PutEmailIdentityDkimAttributesRequest(Mapping):
        pass

    class PutEmailIdentityDkimAttributesResponse(Mapping):
        pass

    class PutEmailIdentityFeedbackAttributesRequest(Mapping):
        pass

    class PutEmailIdentityFeedbackAttributesResponse(Mapping):
        pass

    class PutEmailIdentityMailFromAttributesRequest(Mapping):
        pass

    class PutEmailIdentityMailFromAttributesResponse(Mapping):
        pass

    class SendEmailRequest(Mapping):
        pass

    class SendEmailResponse(Mapping):
        pass

    class Destination(Mapping):
        pass

    class EmailAddress(object):
        pass

    class MessageTag(Mapping):
        pass

    class UpdateConfigurationSetEventDestinationRequest(Mapping):
        pass

    class UpdateConfigurationSetEventDestinationResponse(Mapping):
        pass

    def create_configuration_set(self, ConfigurationSetName: str=None, TrackingOptions: TrackingOptions=None, DeliveryOptions: DeliveryOptions=None, ReputationOptions: ReputationOptions=None, SendingOptions: SendingOptions=None) -> CreateConfigurationSetResponse:
        pass

    def create_configuration_set_event_destination(self, EventDestination: EventDestinationDefinition, EventDestinationName: str, ConfigurationSetName: str) -> CreateConfigurationSetEventDestinationResponse:
        pass

    def create_dedicated_ip_pool(self, PoolName: str) -> CreateDedicatedIpPoolResponse:
        pass

    def create_deliverability_test_report(self, Content: EmailContent, FromEmailAddress: str, ReportName: str=None) -> CreateDeliverabilityTestReportResponse:
        pass

    def create_email_identity(self, EmailIdentity: str) -> CreateEmailIdentityResponse:
        pass

    def delete_configuration_set(self, ConfigurationSetName: str) -> DeleteConfigurationSetResponse:
        pass

    def delete_configuration_set_event_destination(self, EventDestinationName: str, ConfigurationSetName: str) -> DeleteConfigurationSetEventDestinationResponse:
        pass

    def delete_dedicated_ip_pool(self, PoolName: str) -> DeleteDedicatedIpPoolResponse:
        pass

    def delete_email_identity(self, EmailIdentity: str) -> DeleteEmailIdentityResponse:
        pass

    def get_account(self) -> GetAccountResponse:
        pass

    def get_blacklist_reports(self, BlacklistItemNames: List[BlacklistItemName]) -> GetBlacklistReportsResponse:
        pass

    def get_configuration_set(self, ConfigurationSetName: str) -> GetConfigurationSetResponse:
        pass

    def get_configuration_set_event_destinations(self, ConfigurationSetName: str) -> GetConfigurationSetEventDestinationsResponse:
        pass

    def get_dedicated_ip(self, Ip: str) -> GetDedicatedIpResponse:
        pass

    def get_dedicated_ips(self, PoolName: str=None, NextToken: str=None, PageSize: int=None) -> GetDedicatedIpsResponse:
        pass

    def get_deliverability_dashboard_options(self) -> GetDeliverabilityDashboardOptionsResponse:
        pass

    def get_deliverability_test_report(self, ReportId: str) -> GetDeliverabilityTestReportResponse:
        pass

    def get_domain_statistics_report(self, EndDate: Timestamp, StartDate: Timestamp, Domain: str) -> GetDomainStatisticsReportResponse:
        pass

    def get_email_identity(self, EmailIdentity: str) -> GetEmailIdentityResponse:
        pass

    def list_configuration_sets(self, NextToken: str=None, PageSize: int=None) -> ListConfigurationSetsResponse:
        pass

    def list_dedicated_ip_pools(self, NextToken: str=None, PageSize: int=None) -> ListDedicatedIpPoolsResponse:
        pass

    def list_deliverability_test_reports(self, NextToken: str=None, PageSize: int=None) -> ListDeliverabilityTestReportsResponse:
        pass

    def list_email_identities(self, NextToken: str=None, PageSize: int=None) -> ListEmailIdentitiesResponse:
        pass

    def put_account_dedicated_ip_warmup_attributes(self, AutoWarmupEnabled: Enabled=None) -> PutAccountDedicatedIpWarmupAttributesResponse:
        pass

    def put_account_sending_attributes(self, SendingEnabled: Enabled=None) -> PutAccountSendingAttributesResponse:
        pass

    def put_configuration_set_delivery_options(self, ConfigurationSetName: str, SendingPoolName: str=None) -> PutConfigurationSetDeliveryOptionsResponse:
        pass

    def put_configuration_set_reputation_options(self, ConfigurationSetName: str, ReputationMetricsEnabled: Enabled=None) -> PutConfigurationSetReputationOptionsResponse:
        pass

    def put_configuration_set_sending_options(self, ConfigurationSetName: str, SendingEnabled: Enabled=None) -> PutConfigurationSetSendingOptionsResponse:
        pass

    def put_configuration_set_tracking_options(self, ConfigurationSetName: str, CustomRedirectDomain: str=None) -> PutConfigurationSetTrackingOptionsResponse:
        pass

    def put_dedicated_ip_in_pool(self, DestinationPoolName: str, Ip: str) -> PutDedicatedIpInPoolResponse:
        pass

    def put_dedicated_ip_warmup_attributes(self, WarmupPercentage: int, Ip: str) -> PutDedicatedIpWarmupAttributesResponse:
        pass

    def put_deliverability_dashboard_option(self, DashboardEnabled: Enabled) -> PutDeliverabilityDashboardOptionResponse:
        pass

    def put_email_identity_dkim_attributes(self, EmailIdentity: str, SigningEnabled: Enabled=None) -> PutEmailIdentityDkimAttributesResponse:
        pass

    def put_email_identity_feedback_attributes(self, EmailIdentity: str, EmailForwardingEnabled: Enabled=None) -> PutEmailIdentityFeedbackAttributesResponse:
        pass

    def put_email_identity_mail_from_attributes(self, EmailIdentity: str, MailFromDomain: str=None, BehaviorOnMxFailure: str=None) -> PutEmailIdentityMailFromAttributesResponse:
        pass

    def send_email(self, Content: EmailContent, Destination: Destination, FromEmailAddress: str=None, ReplyToAddresses: List[EmailAddress]=None, FeedbackForwardingEmailAddress: str=None, EmailTags: List[MessageTag]=None, ConfigurationSetName: str=None) -> SendEmailResponse:
        pass

    def update_configuration_set_event_destination(self, EventDestination: EventDestinationDefinition, EventDestinationName: str, ConfigurationSetName: str) -> UpdateConfigurationSetEventDestinationResponse:
        pass


class PinpointSMSVoice(BaseClient):
    class CreateConfigurationSetRequest(Mapping):
        pass

    class CreateConfigurationSetResponse(Mapping):
        pass

    class CreateConfigurationSetEventDestinationRequest(Mapping):
        pass

    class CreateConfigurationSetEventDestinationResponse(Mapping):
        pass

    class EventDestinationDefinition(Mapping):
        pass

    class DeleteConfigurationSetRequest(Mapping):
        pass

    class DeleteConfigurationSetResponse(Mapping):
        pass

    class DeleteConfigurationSetEventDestinationRequest(Mapping):
        pass

    class DeleteConfigurationSetEventDestinationResponse(Mapping):
        pass

    class GetConfigurationSetEventDestinationsRequest(Mapping):
        pass

    class GetConfigurationSetEventDestinationsResponse(Mapping):
        pass

    class SendVoiceMessageRequest(Mapping):
        pass

    class SendVoiceMessageResponse(Mapping):
        pass

    class VoiceMessageContent(Mapping):
        pass

    class UpdateConfigurationSetEventDestinationRequest(Mapping):
        pass

    class UpdateConfigurationSetEventDestinationResponse(Mapping):
        pass

    def create_configuration_set(self, ConfigurationSetName: str=None) -> CreateConfigurationSetResponse:
        pass

    def create_configuration_set_event_destination(self, ConfigurationSetName: str, EventDestination: EventDestinationDefinition=None, EventDestinationName: str=None) -> CreateConfigurationSetEventDestinationResponse:
        pass

    def delete_configuration_set(self, ConfigurationSetName: str) -> DeleteConfigurationSetResponse:
        pass

    def delete_configuration_set_event_destination(self, EventDestinationName: str, ConfigurationSetName: str) -> DeleteConfigurationSetEventDestinationResponse:
        pass

    def get_configuration_set_event_destinations(self, ConfigurationSetName: str) -> GetConfigurationSetEventDestinationsResponse:
        pass

    def send_voice_message(self, CallerId: str=None, ConfigurationSetName: str=None, Content: VoiceMessageContent=None, DestinationPhoneNumber: str=None, OriginationPhoneNumber: str=None) -> SendVoiceMessageResponse:
        pass

    def update_configuration_set_event_destination(self, EventDestinationName: str, ConfigurationSetName: str, EventDestination: EventDestinationDefinition=None) -> UpdateConfigurationSetEventDestinationResponse:
        pass


class Polly(BaseClient):
    class DeleteLexiconInput(Mapping):
        pass

    class DeleteLexiconOutput(Mapping):
        pass

    class DescribeVoicesInput(Mapping):
        pass

    class DescribeVoicesOutput(Mapping):
        pass

    class IncludeAdditionalLanguageCodes(object):
        pass

    class GetLexiconInput(Mapping):
        pass

    class GetLexiconOutput(Mapping):
        pass

    class GetSpeechSynthesisTaskInput(Mapping):
        pass

    class GetSpeechSynthesisTaskOutput(Mapping):
        pass

    class ListLexiconsInput(Mapping):
        pass

    class ListLexiconsOutput(Mapping):
        pass

    class ListSpeechSynthesisTasksInput(Mapping):
        pass

    class ListSpeechSynthesisTasksOutput(Mapping):
        pass

    class PutLexiconInput(Mapping):
        pass

    class PutLexiconOutput(Mapping):
        pass

    class StartSpeechSynthesisTaskInput(Mapping):
        pass

    class StartSpeechSynthesisTaskOutput(Mapping):
        pass

    class LexiconName(object):
        pass

    class SpeechMarkType(object):
        pass

    class SynthesizeSpeechInput(Mapping):
        pass

    class SynthesizeSpeechOutput(Mapping):
        pass

    def delete_lexicon(self, Name: str) -> DeleteLexiconOutput:
        pass

    def describe_voices(self, LanguageCode: str=None, IncludeAdditionalLanguageCodes: IncludeAdditionalLanguageCodes=None, NextToken: str=None) -> DescribeVoicesOutput:
        pass

    def get_lexicon(self, Name: str) -> GetLexiconOutput:
        pass

    def get_speech_synthesis_task(self, TaskId: str) -> GetSpeechSynthesisTaskOutput:
        pass

    def list_lexicons(self, NextToken: str=None) -> ListLexiconsOutput:
        pass

    def list_speech_synthesis_tasks(self, MaxResults: int=None, NextToken: str=None, Status: str=None) -> ListSpeechSynthesisTasksOutput:
        pass

    def put_lexicon(self, Content: str, Name: str) -> PutLexiconOutput:
        pass

    def start_speech_synthesis_task(self, VoiceId: str, Text: str, OutputS3BucketName: str, OutputFormat: str, LexiconNames: List[LexiconName]=None, OutputS3KeyPrefix: str=None, SampleRate: str=None, SnsTopicArn: str=None, SpeechMarkTypes: List[SpeechMarkType]=None, TextType: str=None, LanguageCode: str=None) -> StartSpeechSynthesisTaskOutput:
        pass

    def synthesize_speech(self, VoiceId: str, Text: str, OutputFormat: str, LexiconNames: List[LexiconName]=None, SampleRate: str=None, SpeechMarkTypes: List[SpeechMarkType]=None, TextType: str=None, LanguageCode: str=None) -> SynthesizeSpeechOutput:
        pass


class Pricing(BaseClient):
    class DescribeServicesRequest(Mapping):
        pass

    class DescribeServicesResponse(Mapping):
        pass

    class GetAttributeValuesRequest(Mapping):
        pass

    class GetAttributeValuesResponse(Mapping):
        pass

    class GetProductsRequest(Mapping):
        pass

    class GetProductsResponse(Mapping):
        pass

    class Filter(Mapping):
        pass

    def describe_services(self, ServiceCode: str=None, FormatVersion: str=None, NextToken: str=None, MaxResults: int=None) -> DescribeServicesResponse:
        pass

    def get_attribute_values(self, AttributeName: str, ServiceCode: str, NextToken: str=None, MaxResults: int=None) -> GetAttributeValuesResponse:
        pass

    def get_products(self, ServiceCode: str=None, Filters: List[Filter]=None, FormatVersion: str=None, NextToken: str=None, MaxResults: int=None) -> GetProductsResponse:
        pass


class QuickSight(BaseClient):
    class CreateGroupRequest(Mapping):
        pass

    class CreateGroupResponse(Mapping):
        pass

    class CreateGroupMembershipRequest(Mapping):
        pass

    class CreateGroupMembershipResponse(Mapping):
        pass

    class DeleteGroupRequest(Mapping):
        pass

    class DeleteGroupResponse(Mapping):
        pass

    class DeleteGroupMembershipRequest(Mapping):
        pass

    class DeleteGroupMembershipResponse(Mapping):
        pass

    class DeleteUserRequest(Mapping):
        pass

    class DeleteUserResponse(Mapping):
        pass

    class DescribeGroupRequest(Mapping):
        pass

    class DescribeGroupResponse(Mapping):
        pass

    class DescribeUserRequest(Mapping):
        pass

    class DescribeUserResponse(Mapping):
        pass

    class GetDashboardEmbedUrlRequest(Mapping):
        pass

    class GetDashboardEmbedUrlResponse(Mapping):
        pass

    class SessionLifetimeInMinutes(object):
        pass

    class boolean(object):
        pass

    class ListGroupMembershipsRequest(Mapping):
        pass

    class ListGroupMembershipsResponse(Mapping):
        pass

    class ListGroupsRequest(Mapping):
        pass

    class ListGroupsResponse(Mapping):
        pass

    class ListUserGroupsRequest(Mapping):
        pass

    class ListUserGroupsResponse(Mapping):
        pass

    class ListUsersRequest(Mapping):
        pass

    class ListUsersResponse(Mapping):
        pass

    class RegisterUserRequest(Mapping):
        pass

    class RegisterUserResponse(Mapping):
        pass

    class UpdateGroupRequest(Mapping):
        pass

    class UpdateGroupResponse(Mapping):
        pass

    class UpdateUserRequest(Mapping):
        pass

    class UpdateUserResponse(Mapping):
        pass

    def create_group(self, Namespace: str, AwsAccountId: str, GroupName: str, Description: str=None) -> CreateGroupResponse:
        pass

    def create_group_membership(self, Namespace: str, AwsAccountId: str, GroupName: str, MemberName: str) -> CreateGroupMembershipResponse:
        pass

    def delete_group(self, Namespace: str, AwsAccountId: str, GroupName: str) -> DeleteGroupResponse:
        pass

    def delete_group_membership(self, Namespace: str, AwsAccountId: str, GroupName: str, MemberName: str) -> DeleteGroupMembershipResponse:
        pass

    def delete_user(self, Namespace: str, AwsAccountId: str, UserName: str) -> DeleteUserResponse:
        pass

    def describe_group(self, Namespace: str, AwsAccountId: str, GroupName: str) -> DescribeGroupResponse:
        pass

    def describe_user(self, Namespace: str, AwsAccountId: str, UserName: str) -> DescribeUserResponse:
        pass

    def get_dashboard_embed_url(self, IdentityType: str, DashboardId: str, AwsAccountId: str, SessionLifetimeInMinutes: SessionLifetimeInMinutes=None, UndoRedoDisabled: boolean=None, ResetDisabled: boolean=None) -> GetDashboardEmbedUrlResponse:
        pass

    def list_group_memberships(self, Namespace: str, AwsAccountId: str, GroupName: str, NextToken: str=None, MaxResults: int=None) -> ListGroupMembershipsResponse:
        pass

    def list_groups(self, Namespace: str, AwsAccountId: str, NextToken: str=None, MaxResults: int=None) -> ListGroupsResponse:
        pass

    def list_user_groups(self, Namespace: str, AwsAccountId: str, UserName: str, NextToken: str=None, MaxResults: int=None) -> ListUserGroupsResponse:
        pass

    def list_users(self, Namespace: str, AwsAccountId: str, NextToken: str=None, MaxResults: int=None) -> ListUsersResponse:
        pass

    def register_user(self, Namespace: str, AwsAccountId: str, UserRole: str, Email: str, IdentityType: str, IamArn: str=None, SessionName: str=None, UserName: str=None) -> RegisterUserResponse:
        pass

    def update_group(self, Namespace: str, AwsAccountId: str, GroupName: str, Description: str=None) -> UpdateGroupResponse:
        pass

    def update_user(self, Role: str, Email: str, Namespace: str, AwsAccountId: str, UserName: str) -> UpdateUserResponse:
        pass


class RAM(BaseClient):
    class AcceptResourceShareInvitationRequest(Mapping):
        pass

    class AcceptResourceShareInvitationResponse(Mapping):
        pass

    class AssociateResourceShareRequest(Mapping):
        pass

    class AssociateResourceShareResponse(Mapping):
        pass

    class String(object):
        pass

    class CreateResourceShareRequest(Mapping):
        pass

    class CreateResourceShareResponse(Mapping):
        pass

    class Tag(Mapping):
        pass

    class Boolean(object):
        pass

    class DeleteResourceShareRequest(Mapping):
        pass

    class DeleteResourceShareResponse(Mapping):
        pass

    class DisassociateResourceShareRequest(Mapping):
        pass

    class DisassociateResourceShareResponse(Mapping):
        pass

    class EnableSharingWithAwsOrganizationRequest(Mapping):
        pass

    class EnableSharingWithAwsOrganizationResponse(Mapping):
        pass

    class GetResourcePoliciesRequest(Mapping):
        pass

    class GetResourcePoliciesResponse(Mapping):
        pass

    class GetResourceShareAssociationsRequest(Mapping):
        pass

    class GetResourceShareAssociationsResponse(Mapping):
        pass

    class GetResourceShareInvitationsRequest(Mapping):
        pass

    class GetResourceShareInvitationsResponse(Mapping):
        pass

    class GetResourceSharesRequest(Mapping):
        pass

    class GetResourceSharesResponse(Mapping):
        pass

    class TagFilter(Mapping):
        pass

    class ListPrincipalsRequest(Mapping):
        pass

    class ListPrincipalsResponse(Mapping):
        pass

    class ListResourcesRequest(Mapping):
        pass

    class ListResourcesResponse(Mapping):
        pass

    class RejectResourceShareInvitationRequest(Mapping):
        pass

    class RejectResourceShareInvitationResponse(Mapping):
        pass

    class TagResourceRequest(Mapping):
        pass

    class TagResourceResponse(Mapping):
        pass

    class UntagResourceRequest(Mapping):
        pass

    class UntagResourceResponse(Mapping):
        pass

    class TagKey(object):
        pass

    class UpdateResourceShareRequest(Mapping):
        pass

    class UpdateResourceShareResponse(Mapping):
        pass

    def accept_resource_share_invitation(self, resourceShareInvitationArn: str, clientToken: str=None) -> AcceptResourceShareInvitationResponse:
        pass

    def associate_resource_share(self, resourceShareArn: str, resourceArns: List[String]=None, principals: List[String]=None, clientToken: str=None) -> AssociateResourceShareResponse:
        pass

    def create_resource_share(self, name: str, resourceArns: List[String]=None, principals: List[String]=None, tags: List[Tag]=None, allowExternalPrincipals: Boolean=None, clientToken: str=None) -> CreateResourceShareResponse:
        pass

    def delete_resource_share(self, resourceShareArn: str, clientToken: str=None) -> DeleteResourceShareResponse:
        pass

    def disassociate_resource_share(self, resourceShareArn: str, resourceArns: List[String]=None, principals: List[String]=None, clientToken: str=None) -> DisassociateResourceShareResponse:
        pass

    def enable_sharing_with_aws_organization(self) -> EnableSharingWithAwsOrganizationResponse:
        pass

    def get_resource_policies(self, resourceArns: List[String], principal: str=None, nextToken: str=None, maxResults: int=None) -> GetResourcePoliciesResponse:
        pass

    def get_resource_share_associations(self, associationType: str, resourceShareArns: List[String]=None, resourceArn: str=None, principal: str=None, associationStatus: str=None, nextToken: str=None, maxResults: int=None) -> GetResourceShareAssociationsResponse:
        pass

    def get_resource_share_invitations(self, resourceShareInvitationArns: List[String]=None, resourceShareArns: List[String]=None, nextToken: str=None, maxResults: int=None) -> GetResourceShareInvitationsResponse:
        pass

    def get_resource_shares(self, resourceOwner: str, resourceShareArns: List[String]=None, resourceShareStatus: str=None, name: str=None, tagFilters: List[TagFilter]=None, nextToken: str=None, maxResults: int=None) -> GetResourceSharesResponse:
        pass

    def list_principals(self, resourceOwner: str, resourceArn: str=None, principals: List[String]=None, resourceType: str=None, resourceShareArns: List[String]=None, nextToken: str=None, maxResults: int=None) -> ListPrincipalsResponse:
        pass

    def list_resources(self, resourceOwner: str, principal: str=None, resourceType: str=None, resourceArns: List[String]=None, resourceShareArns: List[String]=None, nextToken: str=None, maxResults: int=None) -> ListResourcesResponse:
        pass

    def reject_resource_share_invitation(self, resourceShareInvitationArn: str, clientToken: str=None) -> RejectResourceShareInvitationResponse:
        pass

    def tag_resource(self, tags: List[Tag], resourceShareArn: str) -> TagResourceResponse:
        pass

    def untag_resource(self, tagKeys: List[TagKey], resourceShareArn: str) -> UntagResourceResponse:
        pass

    def update_resource_share(self, resourceShareArn: str, name: str=None, allowExternalPrincipals: Boolean=None, clientToken: str=None) -> UpdateResourceShareResponse:
        pass


class RDS(BaseClient):
    class AddRoleToDBClusterMessage(Mapping):
        pass

    class AddRoleToDBInstanceMessage(Mapping):
        pass

    class AddSourceIdentifierToSubscriptionMessage(Mapping):
        pass

    class AddSourceIdentifierToSubscriptionResult(Mapping):
        pass

    class AddTagsToResourceMessage(Mapping):
        pass

    class Tag(Mapping):
        pass

    class ApplyPendingMaintenanceActionMessage(Mapping):
        pass

    class ApplyPendingMaintenanceActionResult(Mapping):
        pass

    class AuthorizeDBSecurityGroupIngressMessage(Mapping):
        pass

    class AuthorizeDBSecurityGroupIngressResult(Mapping):
        pass

    class BacktrackDBClusterMessage(Mapping):
        pass

    class DBClusterBacktrack(Mapping):
        pass

    class TStamp(object):
        pass

    class BooleanOptional(object):
        pass

    class CopyDBClusterParameterGroupMessage(Mapping):
        pass

    class CopyDBClusterParameterGroupResult(Mapping):
        pass

    class CopyDBClusterSnapshotMessage(Mapping):
        pass

    class CopyDBClusterSnapshotResult(Mapping):
        pass

    class CopyDBParameterGroupMessage(Mapping):
        pass

    class CopyDBParameterGroupResult(Mapping):
        pass

    class CopyDBSnapshotMessage(Mapping):
        pass

    class CopyDBSnapshotResult(Mapping):
        pass

    class CopyOptionGroupMessage(Mapping):
        pass

    class CopyOptionGroupResult(Mapping):
        pass

    class CreateDBClusterMessage(Mapping):
        pass

    class CreateDBClusterResult(Mapping):
        pass

    class String(object):
        pass

    class LongOptional(object):
        pass

    class ScalingConfiguration(Mapping):
        pass

    class CreateDBClusterEndpointMessage(Mapping):
        pass

    class DBClusterEndpoint(Mapping):
        pass

    class CreateDBClusterParameterGroupMessage(Mapping):
        pass

    class CreateDBClusterParameterGroupResult(Mapping):
        pass

    class CreateDBClusterSnapshotMessage(Mapping):
        pass

    class CreateDBClusterSnapshotResult(Mapping):
        pass

    class CreateDBInstanceMessage(Mapping):
        pass

    class CreateDBInstanceResult(Mapping):
        pass

    class ProcessorFeature(Mapping):
        pass

    class CreateDBInstanceReadReplicaMessage(Mapping):
        pass

    class CreateDBInstanceReadReplicaResult(Mapping):
        pass

    class CreateDBParameterGroupMessage(Mapping):
        pass

    class CreateDBParameterGroupResult(Mapping):
        pass

    class CreateDBSecurityGroupMessage(Mapping):
        pass

    class CreateDBSecurityGroupResult(Mapping):
        pass

    class CreateDBSnapshotMessage(Mapping):
        pass

    class CreateDBSnapshotResult(Mapping):
        pass

    class CreateDBSubnetGroupMessage(Mapping):
        pass

    class CreateDBSubnetGroupResult(Mapping):
        pass

    class CreateEventSubscriptionMessage(Mapping):
        pass

    class CreateEventSubscriptionResult(Mapping):
        pass

    class CreateGlobalClusterMessage(Mapping):
        pass

    class CreateGlobalClusterResult(Mapping):
        pass

    class CreateOptionGroupMessage(Mapping):
        pass

    class CreateOptionGroupResult(Mapping):
        pass

    class DeleteDBClusterMessage(Mapping):
        pass

    class DeleteDBClusterResult(Mapping):
        pass

    class Boolean(object):
        pass

    class DeleteDBClusterEndpointMessage(Mapping):
        pass

    class DeleteDBClusterParameterGroupMessage(Mapping):
        pass

    class DeleteDBClusterSnapshotMessage(Mapping):
        pass

    class DeleteDBClusterSnapshotResult(Mapping):
        pass

    class DeleteDBInstanceMessage(Mapping):
        pass

    class DeleteDBInstanceResult(Mapping):
        pass

    class DeleteDBInstanceAutomatedBackupMessage(Mapping):
        pass

    class DeleteDBInstanceAutomatedBackupResult(Mapping):
        pass

    class DeleteDBParameterGroupMessage(Mapping):
        pass

    class DeleteDBSecurityGroupMessage(Mapping):
        pass

    class DeleteDBSnapshotMessage(Mapping):
        pass

    class DeleteDBSnapshotResult(Mapping):
        pass

    class DeleteDBSubnetGroupMessage(Mapping):
        pass

    class DeleteEventSubscriptionMessage(Mapping):
        pass

    class DeleteEventSubscriptionResult(Mapping):
        pass

    class DeleteGlobalClusterMessage(Mapping):
        pass

    class DeleteGlobalClusterResult(Mapping):
        pass

    class DeleteOptionGroupMessage(Mapping):
        pass

    class DescribeAccountAttributesMessage(Mapping):
        pass

    class AccountAttributesMessage(Mapping):
        pass

    class DescribeCertificatesMessage(Mapping):
        pass

    class CertificateMessage(Mapping):
        pass

    class Filter(Mapping):
        pass

    class DescribeDBClusterBacktracksMessage(Mapping):
        pass

    class DBClusterBacktrackMessage(Mapping):
        pass

    class DescribeDBClusterEndpointsMessage(Mapping):
        pass

    class DBClusterEndpointMessage(Mapping):
        pass

    class DescribeDBClusterParameterGroupsMessage(Mapping):
        pass

    class DBClusterParameterGroupsMessage(Mapping):
        pass

    class DescribeDBClusterParametersMessage(Mapping):
        pass

    class DBClusterParameterGroupDetails(Mapping):
        pass

    class DescribeDBClusterSnapshotAttributesMessage(Mapping):
        pass

    class DescribeDBClusterSnapshotAttributesResult(Mapping):
        pass

    class DescribeDBClusterSnapshotsMessage(Mapping):
        pass

    class DBClusterSnapshotMessage(Mapping):
        pass

    class DescribeDBClustersMessage(Mapping):
        pass

    class DBClusterMessage(Mapping):
        pass

    class DescribeDBEngineVersionsMessage(Mapping):
        pass

    class DBEngineVersionMessage(Mapping):
        pass

    class DescribeDBInstanceAutomatedBackupsMessage(Mapping):
        pass

    class DBInstanceAutomatedBackupMessage(Mapping):
        pass

    class DescribeDBInstancesMessage(Mapping):
        pass

    class DBInstanceMessage(Mapping):
        pass

    class DescribeDBLogFilesMessage(Mapping):
        pass

    class DescribeDBLogFilesResponse(Mapping):
        pass

    class Long(object):
        pass

    class DescribeDBParameterGroupsMessage(Mapping):
        pass

    class DBParameterGroupsMessage(Mapping):
        pass

    class DescribeDBParametersMessage(Mapping):
        pass

    class DBParameterGroupDetails(Mapping):
        pass

    class DescribeDBSecurityGroupsMessage(Mapping):
        pass

    class DBSecurityGroupMessage(Mapping):
        pass

    class DescribeDBSnapshotAttributesMessage(Mapping):
        pass

    class DescribeDBSnapshotAttributesResult(Mapping):
        pass

    class DescribeDBSnapshotsMessage(Mapping):
        pass

    class DBSnapshotMessage(Mapping):
        pass

    class DescribeDBSubnetGroupsMessage(Mapping):
        pass

    class DBSubnetGroupMessage(Mapping):
        pass

    class DescribeEngineDefaultClusterParametersMessage(Mapping):
        pass

    class DescribeEngineDefaultClusterParametersResult(Mapping):
        pass

    class DescribeEngineDefaultParametersMessage(Mapping):
        pass

    class DescribeEngineDefaultParametersResult(Mapping):
        pass

    class DescribeEventCategoriesMessage(Mapping):
        pass

    class EventCategoriesMessage(Mapping):
        pass

    class DescribeEventSubscriptionsMessage(Mapping):
        pass

    class EventSubscriptionsMessage(Mapping):
        pass

    class DescribeEventsMessage(Mapping):
        pass

    class EventsMessage(Mapping):
        pass

    class DescribeGlobalClustersMessage(Mapping):
        pass

    class GlobalClustersMessage(Mapping):
        pass

    class DescribeOptionGroupOptionsMessage(Mapping):
        pass

    class OptionGroupOptionsMessage(Mapping):
        pass

    class DescribeOptionGroupsMessage(Mapping):
        pass

    class OptionGroups(Mapping):
        pass

    class DescribeOrderableDBInstanceOptionsMessage(Mapping):
        pass

    class OrderableDBInstanceOptionsMessage(Mapping):
        pass

    class DescribePendingMaintenanceActionsMessage(Mapping):
        pass

    class PendingMaintenanceActionsMessage(Mapping):
        pass

    class DescribeReservedDBInstancesMessage(Mapping):
        pass

    class ReservedDBInstanceMessage(Mapping):
        pass

    class DescribeReservedDBInstancesOfferingsMessage(Mapping):
        pass

    class ReservedDBInstancesOfferingMessage(Mapping):
        pass

    class DescribeSourceRegionsMessage(Mapping):
        pass

    class SourceRegionMessage(Mapping):
        pass

    class DescribeValidDBInstanceModificationsMessage(Mapping):
        pass

    class DescribeValidDBInstanceModificationsResult(Mapping):
        pass

    class DownloadDBLogFilePortionMessage(Mapping):
        pass

    class DownloadDBLogFilePortionDetails(Mapping):
        pass

    class FailoverDBClusterMessage(Mapping):
        pass

    class FailoverDBClusterResult(Mapping):
        pass

    class ListTagsForResourceMessage(Mapping):
        pass

    class TagListMessage(Mapping):
        pass

    class ModifyCurrentDBClusterCapacityMessage(Mapping):
        pass

    class DBClusterCapacityInfo(Mapping):
        pass

    class ModifyDBClusterMessage(Mapping):
        pass

    class ModifyDBClusterResult(Mapping):
        pass

    class CloudwatchLogsExportConfiguration(Mapping):
        pass

    class ModifyDBClusterEndpointMessage(Mapping):
        pass

    class ModifyDBClusterParameterGroupMessage(Mapping):
        pass

    class DBClusterParameterGroupNameMessage(Mapping):
        pass

    class Parameter(Mapping):
        pass

    class ModifyDBClusterSnapshotAttributeMessage(Mapping):
        pass

    class ModifyDBClusterSnapshotAttributeResult(Mapping):
        pass

    class ModifyDBInstanceMessage(Mapping):
        pass

    class ModifyDBInstanceResult(Mapping):
        pass

    class ModifyDBParameterGroupMessage(Mapping):
        pass

    class DBParameterGroupNameMessage(Mapping):
        pass

    class ModifyDBSnapshotMessage(Mapping):
        pass

    class ModifyDBSnapshotResult(Mapping):
        pass

    class ModifyDBSnapshotAttributeMessage(Mapping):
        pass

    class ModifyDBSnapshotAttributeResult(Mapping):
        pass

    class ModifyDBSubnetGroupMessage(Mapping):
        pass

    class ModifyDBSubnetGroupResult(Mapping):
        pass

    class ModifyEventSubscriptionMessage(Mapping):
        pass

    class ModifyEventSubscriptionResult(Mapping):
        pass

    class ModifyGlobalClusterMessage(Mapping):
        pass

    class ModifyGlobalClusterResult(Mapping):
        pass

    class ModifyOptionGroupMessage(Mapping):
        pass

    class ModifyOptionGroupResult(Mapping):
        pass

    class OptionConfiguration(Mapping):
        pass

    class PromoteReadReplicaMessage(Mapping):
        pass

    class PromoteReadReplicaResult(Mapping):
        pass

    class PromoteReadReplicaDBClusterMessage(Mapping):
        pass

    class PromoteReadReplicaDBClusterResult(Mapping):
        pass

    class PurchaseReservedDBInstancesOfferingMessage(Mapping):
        pass

    class PurchaseReservedDBInstancesOfferingResult(Mapping):
        pass

    class RebootDBInstanceMessage(Mapping):
        pass

    class RebootDBInstanceResult(Mapping):
        pass

    class RemoveFromGlobalClusterMessage(Mapping):
        pass

    class RemoveFromGlobalClusterResult(Mapping):
        pass

    class RemoveRoleFromDBClusterMessage(Mapping):
        pass

    class RemoveRoleFromDBInstanceMessage(Mapping):
        pass

    class RemoveSourceIdentifierFromSubscriptionMessage(Mapping):
        pass

    class RemoveSourceIdentifierFromSubscriptionResult(Mapping):
        pass

    class RemoveTagsFromResourceMessage(Mapping):
        pass

    class ResetDBClusterParameterGroupMessage(Mapping):
        pass

    class ResetDBParameterGroupMessage(Mapping):
        pass

    class RestoreDBClusterFromS3Message(Mapping):
        pass

    class RestoreDBClusterFromS3Result(Mapping):
        pass

    class RestoreDBClusterFromSnapshotMessage(Mapping):
        pass

    class RestoreDBClusterFromSnapshotResult(Mapping):
        pass

    class RestoreDBClusterToPointInTimeMessage(Mapping):
        pass

    class RestoreDBClusterToPointInTimeResult(Mapping):
        pass

    class RestoreDBInstanceFromDBSnapshotMessage(Mapping):
        pass

    class RestoreDBInstanceFromDBSnapshotResult(Mapping):
        pass

    class RestoreDBInstanceFromS3Message(Mapping):
        pass

    class RestoreDBInstanceFromS3Result(Mapping):
        pass

    class RestoreDBInstanceToPointInTimeMessage(Mapping):
        pass

    class RestoreDBInstanceToPointInTimeResult(Mapping):
        pass

    class RevokeDBSecurityGroupIngressMessage(Mapping):
        pass

    class RevokeDBSecurityGroupIngressResult(Mapping):
        pass

    class StartDBClusterMessage(Mapping):
        pass

    class StartDBClusterResult(Mapping):
        pass

    class StartDBInstanceMessage(Mapping):
        pass

    class StartDBInstanceResult(Mapping):
        pass

    class StopDBClusterMessage(Mapping):
        pass

    class StopDBClusterResult(Mapping):
        pass

    class StopDBInstanceMessage(Mapping):
        pass

    class StopDBInstanceResult(Mapping):
        pass

    def add_role_to_db_cluster(self, RoleArn: str, DBClusterIdentifier: str):
        pass

    def add_role_to_db_instance(self, FeatureName: str, RoleArn: str, DBInstanceIdentifier: str):
        pass

    def add_source_identifier_to_subscription(self, SourceIdentifier: str, SubscriptionName: str) -> AddSourceIdentifierToSubscriptionResult:
        pass

    def add_tags_to_resource(self, Tags: List[Tag], ResourceName: str):
        pass

    def apply_pending_maintenance_action(self, OptInType: str, ApplyAction: str, ResourceIdentifier: str) -> ApplyPendingMaintenanceActionResult:
        pass

    def authorize_db_security_group_ingress(self, DBSecurityGroupName: str, CIDRIP: str=None, EC2SecurityGroupName: str=None, EC2SecurityGroupId: str=None, EC2SecurityGroupOwnerId: str=None) -> AuthorizeDBSecurityGroupIngressResult:
        pass

    def backtrack_db_cluster(self, BacktrackTo: TStamp, DBClusterIdentifier: str, Force: BooleanOptional=None, UseEarliestTimeOnPointInTimeUnavailable: BooleanOptional=None) -> DBClusterBacktrack:
        pass

    def copy_db_cluster_parameter_group(self, TargetDBClusterParameterGroupDescription: str, TargetDBClusterParameterGroupIdentifier: str, SourceDBClusterParameterGroupIdentifier: str, Tags: List[Tag]=None) -> CopyDBClusterParameterGroupResult:
        pass

    def copy_db_cluster_snapshot(self, TargetDBClusterSnapshotIdentifier: str, SourceDBClusterSnapshotIdentifier: str, KmsKeyId: str=None, PreSignedUrl: str=None, CopyTags: BooleanOptional=None, Tags: List[Tag]=None, SourceRegion: str=None) -> CopyDBClusterSnapshotResult:
        pass

    def copy_db_parameter_group(self, TargetDBParameterGroupDescription: str, TargetDBParameterGroupIdentifier: str, SourceDBParameterGroupIdentifier: str, Tags: List[Tag]=None) -> CopyDBParameterGroupResult:
        pass

    def copy_db_snapshot(self, TargetDBSnapshotIdentifier: str, SourceDBSnapshotIdentifier: str, KmsKeyId: str=None, Tags: List[Tag]=None, CopyTags: BooleanOptional=None, PreSignedUrl: str=None, OptionGroupName: str=None, SourceRegion: str=None) -> CopyDBSnapshotResult:
        pass

    def copy_option_group(self, TargetOptionGroupDescription: str, TargetOptionGroupIdentifier: str, SourceOptionGroupIdentifier: str, Tags: List[Tag]=None) -> CopyOptionGroupResult:
        pass

    def create_db_cluster(self, Engine: str, DBClusterIdentifier: str, AvailabilityZones: List[String]=None, BackupRetentionPeriod: int=None, CharacterSetName: str=None, DatabaseName: str=None, DBClusterParameterGroupName: str=None, VpcSecurityGroupIds: List[String]=None, DBSubnetGroupName: str=None, EngineVersion: str=None, Port: int=None, MasterUsername: str=None, MasterUserPassword: str=None, OptionGroupName: str=None, PreferredBackupWindow: str=None, PreferredMaintenanceWindow: str=None, ReplicationSourceIdentifier: str=None, Tags: List[Tag]=None, StorageEncrypted: BooleanOptional=None, KmsKeyId: str=None, PreSignedUrl: str=None, EnableIAMDatabaseAuthentication: BooleanOptional=None, BacktrackWindow: LongOptional=None, EnableCloudwatchLogsExports: List[String]=None, EngineMode: str=None, ScalingConfiguration: ScalingConfiguration=None, DeletionProtection: BooleanOptional=None, GlobalClusterIdentifier: str=None, SourceRegion: str=None) -> CreateDBClusterResult:
        pass

    def create_db_cluster_endpoint(self, EndpointType: str, DBClusterEndpointIdentifier: str, DBClusterIdentifier: str, StaticMembers: List[String]=None, ExcludedMembers: List[String]=None) -> DBClusterEndpoint:
        pass

    def create_db_cluster_parameter_group(self, Description: str, DBParameterGroupFamily: str, DBClusterParameterGroupName: str, Tags: List[Tag]=None) -> CreateDBClusterParameterGroupResult:
        pass

    def create_db_cluster_snapshot(self, DBClusterIdentifier: str, DBClusterSnapshotIdentifier: str, Tags: List[Tag]=None) -> CreateDBClusterSnapshotResult:
        pass

    def create_db_instance(self, Engine: str, DBInstanceClass: str, DBInstanceIdentifier: str, DBName: str=None, AllocatedStorage: int=None, MasterUsername: str=None, MasterUserPassword: str=None, DBSecurityGroups: List[String]=None, VpcSecurityGroupIds: List[String]=None, AvailabilityZone: str=None, DBSubnetGroupName: str=None, PreferredMaintenanceWindow: str=None, DBParameterGroupName: str=None, BackupRetentionPeriod: int=None, PreferredBackupWindow: str=None, Port: int=None, MultiAZ: BooleanOptional=None, EngineVersion: str=None, AutoMinorVersionUpgrade: BooleanOptional=None, LicenseModel: str=None, Iops: int=None, OptionGroupName: str=None, CharacterSetName: str=None, PubliclyAccessible: BooleanOptional=None, Tags: List[Tag]=None, DBClusterIdentifier: str=None, StorageType: str=None, TdeCredentialArn: str=None, TdeCredentialPassword: str=None, StorageEncrypted: BooleanOptional=None, KmsKeyId: str=None, Domain: str=None, CopyTagsToSnapshot: BooleanOptional=None, MonitoringInterval: int=None, MonitoringRoleArn: str=None, DomainIAMRoleName: str=None, PromotionTier: int=None, Timezone: str=None, EnableIAMDatabaseAuthentication: BooleanOptional=None, EnablePerformanceInsights: BooleanOptional=None, PerformanceInsightsKMSKeyId: str=None, PerformanceInsightsRetentionPeriod: int=None, EnableCloudwatchLogsExports: List[String]=None, ProcessorFeatures: List[ProcessorFeature]=None, DeletionProtection: BooleanOptional=None) -> CreateDBInstanceResult:
        pass

    def create_db_instance_read_replica(self, SourceDBInstanceIdentifier: str, DBInstanceIdentifier: str, DBInstanceClass: str=None, AvailabilityZone: str=None, Port: int=None, MultiAZ: BooleanOptional=None, AutoMinorVersionUpgrade: BooleanOptional=None, Iops: int=None, OptionGroupName: str=None, PubliclyAccessible: BooleanOptional=None, Tags: List[Tag]=None, DBSubnetGroupName: str=None, VpcSecurityGroupIds: List[String]=None, StorageType: str=None, CopyTagsToSnapshot: BooleanOptional=None, MonitoringInterval: int=None, MonitoringRoleArn: str=None, KmsKeyId: str=None, PreSignedUrl: str=None, EnableIAMDatabaseAuthentication: BooleanOptional=None, EnablePerformanceInsights: BooleanOptional=None, PerformanceInsightsKMSKeyId: str=None, PerformanceInsightsRetentionPeriod: int=None, EnableCloudwatchLogsExports: List[String]=None, ProcessorFeatures: List[ProcessorFeature]=None, UseDefaultProcessorFeatures: BooleanOptional=None, DeletionProtection: BooleanOptional=None, SourceRegion: str=None) -> CreateDBInstanceReadReplicaResult:
        pass

    def create_db_parameter_group(self, Description: str, DBParameterGroupFamily: str, DBParameterGroupName: str, Tags: List[Tag]=None) -> CreateDBParameterGroupResult:
        pass

    def create_db_security_group(self, DBSecurityGroupDescription: str, DBSecurityGroupName: str, Tags: List[Tag]=None) -> CreateDBSecurityGroupResult:
        pass

    def create_db_snapshot(self, DBInstanceIdentifier: str, DBSnapshotIdentifier: str, Tags: List[Tag]=None) -> CreateDBSnapshotResult:
        pass

    def create_db_subnet_group(self, SubnetIds: List[String], DBSubnetGroupDescription: str, DBSubnetGroupName: str, Tags: List[Tag]=None) -> CreateDBSubnetGroupResult:
        pass

    def create_event_subscription(self, SnsTopicArn: str, SubscriptionName: str, SourceType: str=None, EventCategories: List[String]=None, SourceIds: List[String]=None, Enabled: BooleanOptional=None, Tags: List[Tag]=None) -> CreateEventSubscriptionResult:
        pass

    def create_global_cluster(self, GlobalClusterIdentifier: str=None, SourceDBClusterIdentifier: str=None, Engine: str=None, EngineVersion: str=None, DeletionProtection: BooleanOptional=None, DatabaseName: str=None, StorageEncrypted: BooleanOptional=None) -> CreateGlobalClusterResult:
        pass

    def create_option_group(self, OptionGroupDescription: str, MajorEngineVersion: str, EngineName: str, OptionGroupName: str, Tags: List[Tag]=None) -> CreateOptionGroupResult:
        pass

    def delete_db_cluster(self, DBClusterIdentifier: str, SkipFinalSnapshot: Boolean=None, FinalDBSnapshotIdentifier: str=None) -> DeleteDBClusterResult:
        pass

    def delete_db_cluster_endpoint(self, DBClusterEndpointIdentifier: str) -> DBClusterEndpoint:
        pass

    def delete_db_cluster_parameter_group(self, DBClusterParameterGroupName: str):
        pass

    def delete_db_cluster_snapshot(self, DBClusterSnapshotIdentifier: str) -> DeleteDBClusterSnapshotResult:
        pass

    def delete_db_instance(self, DBInstanceIdentifier: str, SkipFinalSnapshot: Boolean=None, FinalDBSnapshotIdentifier: str=None, DeleteAutomatedBackups: BooleanOptional=None) -> DeleteDBInstanceResult:
        pass

    def delete_db_instance_automated_backup(self, DbiResourceId: str) -> DeleteDBInstanceAutomatedBackupResult:
        pass

    def delete_db_parameter_group(self, DBParameterGroupName: str):
        pass

    def delete_db_security_group(self, DBSecurityGroupName: str):
        pass

    def delete_db_snapshot(self, DBSnapshotIdentifier: str) -> DeleteDBSnapshotResult:
        pass

    def delete_db_subnet_group(self, DBSubnetGroupName: str):
        pass

    def delete_event_subscription(self, SubscriptionName: str) -> DeleteEventSubscriptionResult:
        pass

    def delete_global_cluster(self, GlobalClusterIdentifier: str) -> DeleteGlobalClusterResult:
        pass

    def delete_option_group(self, OptionGroupName: str):
        pass

    def describe_account_attributes(self) -> AccountAttributesMessage:
        pass

    def describe_certificates(self, CertificateIdentifier: str=None, Filters: List[Filter]=None, MaxRecords: int=None, Marker: str=None) -> CertificateMessage:
        pass

    def describe_db_cluster_backtracks(self, DBClusterIdentifier: str, BacktrackIdentifier: str=None, Filters: List[Filter]=None, MaxRecords: int=None, Marker: str=None) -> DBClusterBacktrackMessage:
        pass

    def describe_db_cluster_endpoints(self, DBClusterIdentifier: str=None, DBClusterEndpointIdentifier: str=None, Filters: List[Filter]=None, MaxRecords: int=None, Marker: str=None) -> DBClusterEndpointMessage:
        pass

    def describe_db_cluster_parameter_groups(self, DBClusterParameterGroupName: str=None, Filters: List[Filter]=None, MaxRecords: int=None, Marker: str=None) -> DBClusterParameterGroupsMessage:
        pass

    def describe_db_cluster_parameters(self, DBClusterParameterGroupName: str, Source: str=None, Filters: List[Filter]=None, MaxRecords: int=None, Marker: str=None) -> DBClusterParameterGroupDetails:
        pass

    def describe_db_cluster_snapshot_attributes(self, DBClusterSnapshotIdentifier: str) -> DescribeDBClusterSnapshotAttributesResult:
        pass

    def describe_db_cluster_snapshots(self, DBClusterIdentifier: str=None, DBClusterSnapshotIdentifier: str=None, SnapshotType: str=None, Filters: List[Filter]=None, MaxRecords: int=None, Marker: str=None, IncludeShared: Boolean=None, IncludePublic: Boolean=None) -> DBClusterSnapshotMessage:
        pass

    def describe_db_clusters(self, DBClusterIdentifier: str=None, Filters: List[Filter]=None, MaxRecords: int=None, Marker: str=None) -> DBClusterMessage:
        pass

    def describe_db_engine_versions(self, Engine: str=None, EngineVersion: str=None, DBParameterGroupFamily: str=None, Filters: List[Filter]=None, MaxRecords: int=None, Marker: str=None, DefaultOnly: Boolean=None, ListSupportedCharacterSets: BooleanOptional=None, ListSupportedTimezones: BooleanOptional=None) -> DBEngineVersionMessage:
        pass

    def describe_db_instance_automated_backups(self, DbiResourceId: str=None, DBInstanceIdentifier: str=None, Filters: List[Filter]=None, MaxRecords: int=None, Marker: str=None) -> DBInstanceAutomatedBackupMessage:
        pass

    def describe_db_instances(self, DBInstanceIdentifier: str=None, Filters: List[Filter]=None, MaxRecords: int=None, Marker: str=None) -> DBInstanceMessage:
        pass

    def describe_db_log_files(self, DBInstanceIdentifier: str, FilenameContains: str=None, FileLastWritten: Long=None, FileSize: Long=None, Filters: List[Filter]=None, MaxRecords: int=None, Marker: str=None) -> DescribeDBLogFilesResponse:
        pass

    def describe_db_parameter_groups(self, DBParameterGroupName: str=None, Filters: List[Filter]=None, MaxRecords: int=None, Marker: str=None) -> DBParameterGroupsMessage:
        pass

    def describe_db_parameters(self, DBParameterGroupName: str, Source: str=None, Filters: List[Filter]=None, MaxRecords: int=None, Marker: str=None) -> DBParameterGroupDetails:
        pass

    def describe_db_security_groups(self, DBSecurityGroupName: str=None, Filters: List[Filter]=None, MaxRecords: int=None, Marker: str=None) -> DBSecurityGroupMessage:
        pass

    def describe_db_snapshot_attributes(self, DBSnapshotIdentifier: str) -> DescribeDBSnapshotAttributesResult:
        pass

    def describe_db_snapshots(self, DBInstanceIdentifier: str=None, DBSnapshotIdentifier: str=None, SnapshotType: str=None, Filters: List[Filter]=None, MaxRecords: int=None, Marker: str=None, IncludeShared: Boolean=None, IncludePublic: Boolean=None, DbiResourceId: str=None) -> DBSnapshotMessage:
        pass

    def describe_db_subnet_groups(self, DBSubnetGroupName: str=None, Filters: List[Filter]=None, MaxRecords: int=None, Marker: str=None) -> DBSubnetGroupMessage:
        pass

    def describe_engine_default_cluster_parameters(self, DBParameterGroupFamily: str, Filters: List[Filter]=None, MaxRecords: int=None, Marker: str=None) -> DescribeEngineDefaultClusterParametersResult:
        pass

    def describe_engine_default_parameters(self, DBParameterGroupFamily: str, Filters: List[Filter]=None, MaxRecords: int=None, Marker: str=None) -> DescribeEngineDefaultParametersResult:
        pass

    def describe_event_categories(self, SourceType: str=None, Filters: List[Filter]=None) -> EventCategoriesMessage:
        pass

    def describe_event_subscriptions(self, SubscriptionName: str=None, Filters: List[Filter]=None, MaxRecords: int=None, Marker: str=None) -> EventSubscriptionsMessage:
        pass

    def describe_events(self, SourceIdentifier: str=None, SourceType: str=None, StartTime: TStamp=None, EndTime: TStamp=None, Duration: int=None, EventCategories: List[String]=None, Filters: List[Filter]=None, MaxRecords: int=None, Marker: str=None) -> EventsMessage:
        pass

    def describe_global_clusters(self, GlobalClusterIdentifier: str=None, Filters: List[Filter]=None, MaxRecords: int=None, Marker: str=None) -> GlobalClustersMessage:
        pass

    def describe_option_group_options(self, EngineName: str, MajorEngineVersion: str=None, Filters: List[Filter]=None, MaxRecords: int=None, Marker: str=None) -> OptionGroupOptionsMessage:
        pass

    def describe_option_groups(self, OptionGroupName: str=None, Filters: List[Filter]=None, Marker: str=None, MaxRecords: int=None, EngineName: str=None, MajorEngineVersion: str=None) -> OptionGroups:
        pass

    def describe_orderable_db_instance_options(self, Engine: str, EngineVersion: str=None, DBInstanceClass: str=None, LicenseModel: str=None, Vpc: BooleanOptional=None, Filters: List[Filter]=None, MaxRecords: int=None, Marker: str=None) -> OrderableDBInstanceOptionsMessage:
        pass

    def describe_pending_maintenance_actions(self, ResourceIdentifier: str=None, Filters: List[Filter]=None, Marker: str=None, MaxRecords: int=None) -> PendingMaintenanceActionsMessage:
        pass

    def describe_reserved_db_instances(self, ReservedDBInstanceId: str=None, ReservedDBInstancesOfferingId: str=None, DBInstanceClass: str=None, Duration: str=None, ProductDescription: str=None, OfferingType: str=None, MultiAZ: BooleanOptional=None, Filters: List[Filter]=None, MaxRecords: int=None, Marker: str=None) -> ReservedDBInstanceMessage:
        pass

    def describe_reserved_db_instances_offerings(self, ReservedDBInstancesOfferingId: str=None, DBInstanceClass: str=None, Duration: str=None, ProductDescription: str=None, OfferingType: str=None, MultiAZ: BooleanOptional=None, Filters: List[Filter]=None, MaxRecords: int=None, Marker: str=None) -> ReservedDBInstancesOfferingMessage:
        pass

    def describe_source_regions(self, RegionName: str=None, MaxRecords: int=None, Marker: str=None, Filters: List[Filter]=None) -> SourceRegionMessage:
        pass

    def describe_valid_db_instance_modifications(self, DBInstanceIdentifier: str) -> DescribeValidDBInstanceModificationsResult:
        pass

    def download_db_log_file_portion(self, LogFileName: str, DBInstanceIdentifier: str, Marker: str=None, NumberOfLines: int=None) -> DownloadDBLogFilePortionDetails:
        pass

    def failover_db_cluster(self, DBClusterIdentifier: str, TargetDBInstanceIdentifier: str=None) -> FailoverDBClusterResult:
        pass

    def list_tags_for_resource(self, ResourceName: str, Filters: List[Filter]=None) -> TagListMessage:
        pass

    def modify_current_db_cluster_capacity(self, DBClusterIdentifier: str, Capacity: int=None, SecondsBeforeTimeout: int=None, TimeoutAction: str=None) -> DBClusterCapacityInfo:
        pass

    def modify_db_cluster(self, DBClusterIdentifier: str, NewDBClusterIdentifier: str=None, ApplyImmediately: Boolean=None, BackupRetentionPeriod: int=None, DBClusterParameterGroupName: str=None, VpcSecurityGroupIds: List[String]=None, Port: int=None, MasterUserPassword: str=None, OptionGroupName: str=None, PreferredBackupWindow: str=None, PreferredMaintenanceWindow: str=None, EnableIAMDatabaseAuthentication: BooleanOptional=None, BacktrackWindow: LongOptional=None, CloudwatchLogsExportConfiguration: CloudwatchLogsExportConfiguration=None, EngineVersion: str=None, ScalingConfiguration: ScalingConfiguration=None, DeletionProtection: BooleanOptional=None, EnableHttpEndpoint: BooleanOptional=None) -> ModifyDBClusterResult:
        pass

    def modify_db_cluster_endpoint(self, DBClusterEndpointIdentifier: str, EndpointType: str=None, StaticMembers: List[String]=None, ExcludedMembers: List[String]=None) -> DBClusterEndpoint:
        pass

    def modify_db_cluster_parameter_group(self, Parameters: List[Parameter], DBClusterParameterGroupName: str) -> DBClusterParameterGroupNameMessage:
        pass

    def modify_db_cluster_snapshot_attribute(self, AttributeName: str, DBClusterSnapshotIdentifier: str, ValuesToAdd: List[String]=None, ValuesToRemove: List[String]=None) -> ModifyDBClusterSnapshotAttributeResult:
        pass

    def modify_db_instance(self, DBInstanceIdentifier: str, AllocatedStorage: int=None, DBInstanceClass: str=None, DBSubnetGroupName: str=None, DBSecurityGroups: List[String]=None, VpcSecurityGroupIds: List[String]=None, ApplyImmediately: Boolean=None, MasterUserPassword: str=None, DBParameterGroupName: str=None, BackupRetentionPeriod: int=None, PreferredBackupWindow: str=None, PreferredMaintenanceWindow: str=None, MultiAZ: BooleanOptional=None, EngineVersion: str=None, AllowMajorVersionUpgrade: Boolean=None, AutoMinorVersionUpgrade: BooleanOptional=None, LicenseModel: str=None, Iops: int=None, OptionGroupName: str=None, NewDBInstanceIdentifier: str=None, StorageType: str=None, TdeCredentialArn: str=None, TdeCredentialPassword: str=None, CACertificateIdentifier: str=None, Domain: str=None, CopyTagsToSnapshot: BooleanOptional=None, MonitoringInterval: int=None, DBPortNumber: int=None, PubliclyAccessible: BooleanOptional=None, MonitoringRoleArn: str=None, DomainIAMRoleName: str=None, PromotionTier: int=None, EnableIAMDatabaseAuthentication: BooleanOptional=None, EnablePerformanceInsights: BooleanOptional=None, PerformanceInsightsKMSKeyId: str=None, PerformanceInsightsRetentionPeriod: int=None, CloudwatchLogsExportConfiguration: CloudwatchLogsExportConfiguration=None, ProcessorFeatures: List[ProcessorFeature]=None, UseDefaultProcessorFeatures: BooleanOptional=None, DeletionProtection: BooleanOptional=None) -> ModifyDBInstanceResult:
        pass

    def modify_db_parameter_group(self, Parameters: List[Parameter], DBParameterGroupName: str) -> DBParameterGroupNameMessage:
        pass

    def modify_db_snapshot(self, DBSnapshotIdentifier: str, EngineVersion: str=None, OptionGroupName: str=None) -> ModifyDBSnapshotResult:
        pass

    def modify_db_snapshot_attribute(self, AttributeName: str, DBSnapshotIdentifier: str, ValuesToAdd: List[String]=None, ValuesToRemove: List[String]=None) -> ModifyDBSnapshotAttributeResult:
        pass

    def modify_db_subnet_group(self, SubnetIds: List[String], DBSubnetGroupName: str, DBSubnetGroupDescription: str=None) -> ModifyDBSubnetGroupResult:
        pass

    def modify_event_subscription(self, SubscriptionName: str, SnsTopicArn: str=None, SourceType: str=None, EventCategories: List[String]=None, Enabled: BooleanOptional=None) -> ModifyEventSubscriptionResult:
        pass

    def modify_global_cluster(self, GlobalClusterIdentifier: str=None, NewGlobalClusterIdentifier: str=None, DeletionProtection: BooleanOptional=None) -> ModifyGlobalClusterResult:
        pass

    def modify_option_group(self, OptionGroupName: str, OptionsToInclude: List[OptionConfiguration]=None, OptionsToRemove: List[String]=None, ApplyImmediately: Boolean=None) -> ModifyOptionGroupResult:
        pass

    def promote_read_replica(self, DBInstanceIdentifier: str, BackupRetentionPeriod: int=None, PreferredBackupWindow: str=None) -> PromoteReadReplicaResult:
        pass

    def promote_read_replica_db_cluster(self, DBClusterIdentifier: str) -> PromoteReadReplicaDBClusterResult:
        pass

    def purchase_reserved_db_instances_offering(self, ReservedDBInstancesOfferingId: str, ReservedDBInstanceId: str=None, DBInstanceCount: int=None, Tags: List[Tag]=None) -> PurchaseReservedDBInstancesOfferingResult:
        pass

    def reboot_db_instance(self, DBInstanceIdentifier: str, ForceFailover: BooleanOptional=None) -> RebootDBInstanceResult:
        pass

    def remove_from_global_cluster(self, GlobalClusterIdentifier: str=None, DbClusterIdentifier: str=None) -> RemoveFromGlobalClusterResult:
        pass

    def remove_role_from_db_cluster(self, RoleArn: str, DBClusterIdentifier: str):
        pass

    def remove_role_from_db_instance(self, FeatureName: str, RoleArn: str, DBInstanceIdentifier: str):
        pass

    def remove_source_identifier_from_subscription(self, SourceIdentifier: str, SubscriptionName: str) -> RemoveSourceIdentifierFromSubscriptionResult:
        pass

    def remove_tags_from_resource(self, TagKeys: List[String], ResourceName: str):
        pass

    def reset_db_cluster_parameter_group(self, DBClusterParameterGroupName: str, ResetAllParameters: Boolean=None, Parameters: List[Parameter]=None) -> DBClusterParameterGroupNameMessage:
        pass

    def reset_db_parameter_group(self, DBParameterGroupName: str, ResetAllParameters: Boolean=None, Parameters: List[Parameter]=None) -> DBParameterGroupNameMessage:
        pass

    def restore_db_cluster_from_s3(self, S3IngestionRoleArn: str, S3BucketName: str, SourceEngineVersion: str, SourceEngine: str, MasterUserPassword: str, MasterUsername: str, Engine: str, DBClusterIdentifier: str, AvailabilityZones: List[String]=None, BackupRetentionPeriod: int=None, CharacterSetName: str=None, DatabaseName: str=None, DBClusterParameterGroupName: str=None, VpcSecurityGroupIds: List[String]=None, DBSubnetGroupName: str=None, EngineVersion: str=None, Port: int=None, OptionGroupName: str=None, PreferredBackupWindow: str=None, PreferredMaintenanceWindow: str=None, Tags: List[Tag]=None, StorageEncrypted: BooleanOptional=None, KmsKeyId: str=None, EnableIAMDatabaseAuthentication: BooleanOptional=None, S3Prefix: str=None, BacktrackWindow: LongOptional=None, EnableCloudwatchLogsExports: List[String]=None, DeletionProtection: BooleanOptional=None) -> RestoreDBClusterFromS3Result:
        pass

    def restore_db_cluster_from_snapshot(self, Engine: str, SnapshotIdentifier: str, DBClusterIdentifier: str, AvailabilityZones: List[String]=None, EngineVersion: str=None, Port: int=None, DBSubnetGroupName: str=None, DatabaseName: str=None, OptionGroupName: str=None, VpcSecurityGroupIds: List[String]=None, Tags: List[Tag]=None, KmsKeyId: str=None, EnableIAMDatabaseAuthentication: BooleanOptional=None, BacktrackWindow: LongOptional=None, EnableCloudwatchLogsExports: List[String]=None, EngineMode: str=None, ScalingConfiguration: ScalingConfiguration=None, DBClusterParameterGroupName: str=None, DeletionProtection: BooleanOptional=None) -> RestoreDBClusterFromSnapshotResult:
        pass

    def restore_db_cluster_to_point_in_time(self, SourceDBClusterIdentifier: str, DBClusterIdentifier: str, RestoreType: str=None, RestoreToTime: TStamp=None, UseLatestRestorableTime: Boolean=None, Port: int=None, DBSubnetGroupName: str=None, OptionGroupName: str=None, VpcSecurityGroupIds: List[String]=None, Tags: List[Tag]=None, KmsKeyId: str=None, EnableIAMDatabaseAuthentication: BooleanOptional=None, BacktrackWindow: LongOptional=None, EnableCloudwatchLogsExports: List[String]=None, DBClusterParameterGroupName: str=None, DeletionProtection: BooleanOptional=None) -> RestoreDBClusterToPointInTimeResult:
        pass

    def restore_db_instance_from_db_snapshot(self, DBSnapshotIdentifier: str, DBInstanceIdentifier: str, DBInstanceClass: str=None, Port: int=None, AvailabilityZone: str=None, DBSubnetGroupName: str=None, MultiAZ: BooleanOptional=None, PubliclyAccessible: BooleanOptional=None, AutoMinorVersionUpgrade: BooleanOptional=None, LicenseModel: str=None, DBName: str=None, Engine: str=None, Iops: int=None, OptionGroupName: str=None, Tags: List[Tag]=None, StorageType: str=None, TdeCredentialArn: str=None, TdeCredentialPassword: str=None, VpcSecurityGroupIds: List[String]=None, Domain: str=None, CopyTagsToSnapshot: BooleanOptional=None, DomainIAMRoleName: str=None, EnableIAMDatabaseAuthentication: BooleanOptional=None, EnableCloudwatchLogsExports: List[String]=None, ProcessorFeatures: List[ProcessorFeature]=None, UseDefaultProcessorFeatures: BooleanOptional=None, DBParameterGroupName: str=None, DeletionProtection: BooleanOptional=None) -> RestoreDBInstanceFromDBSnapshotResult:
        pass

    def restore_db_instance_from_s3(self, S3IngestionRoleArn: str, S3BucketName: str, SourceEngineVersion: str, SourceEngine: str, Engine: str, DBInstanceClass: str, DBInstanceIdentifier: str, DBName: str=None, AllocatedStorage: int=None, MasterUsername: str=None, MasterUserPassword: str=None, DBSecurityGroups: List[String]=None, VpcSecurityGroupIds: List[String]=None, AvailabilityZone: str=None, DBSubnetGroupName: str=None, PreferredMaintenanceWindow: str=None, DBParameterGroupName: str=None, BackupRetentionPeriod: int=None, PreferredBackupWindow: str=None, Port: int=None, MultiAZ: BooleanOptional=None, EngineVersion: str=None, AutoMinorVersionUpgrade: BooleanOptional=None, LicenseModel: str=None, Iops: int=None, OptionGroupName: str=None, PubliclyAccessible: BooleanOptional=None, Tags: List[Tag]=None, StorageType: str=None, StorageEncrypted: BooleanOptional=None, KmsKeyId: str=None, CopyTagsToSnapshot: BooleanOptional=None, MonitoringInterval: int=None, MonitoringRoleArn: str=None, EnableIAMDatabaseAuthentication: BooleanOptional=None, S3Prefix: str=None, EnablePerformanceInsights: BooleanOptional=None, PerformanceInsightsKMSKeyId: str=None, PerformanceInsightsRetentionPeriod: int=None, EnableCloudwatchLogsExports: List[String]=None, ProcessorFeatures: List[ProcessorFeature]=None, UseDefaultProcessorFeatures: BooleanOptional=None, DeletionProtection: BooleanOptional=None) -> RestoreDBInstanceFromS3Result:
        pass

    def restore_db_instance_to_point_in_time(self, TargetDBInstanceIdentifier: str, SourceDBInstanceIdentifier: str=None, RestoreTime: TStamp=None, UseLatestRestorableTime: Boolean=None, DBInstanceClass: str=None, Port: int=None, AvailabilityZone: str=None, DBSubnetGroupName: str=None, MultiAZ: BooleanOptional=None, PubliclyAccessible: BooleanOptional=None, AutoMinorVersionUpgrade: BooleanOptional=None, LicenseModel: str=None, DBName: str=None, Engine: str=None, Iops: int=None, OptionGroupName: str=None, CopyTagsToSnapshot: BooleanOptional=None, Tags: List[Tag]=None, StorageType: str=None, TdeCredentialArn: str=None, TdeCredentialPassword: str=None, VpcSecurityGroupIds: List[String]=None, Domain: str=None, DomainIAMRoleName: str=None, EnableIAMDatabaseAuthentication: BooleanOptional=None, EnableCloudwatchLogsExports: List[String]=None, ProcessorFeatures: List[ProcessorFeature]=None, UseDefaultProcessorFeatures: BooleanOptional=None, DBParameterGroupName: str=None, DeletionProtection: BooleanOptional=None, SourceDbiResourceId: str=None) -> RestoreDBInstanceToPointInTimeResult:
        pass

    def revoke_db_security_group_ingress(self, DBSecurityGroupName: str, CIDRIP: str=None, EC2SecurityGroupName: str=None, EC2SecurityGroupId: str=None, EC2SecurityGroupOwnerId: str=None) -> RevokeDBSecurityGroupIngressResult:
        pass

    def start_db_cluster(self, DBClusterIdentifier: str) -> StartDBClusterResult:
        pass

    def start_db_instance(self, DBInstanceIdentifier: str) -> StartDBInstanceResult:
        pass

    def stop_db_cluster(self, DBClusterIdentifier: str) -> StopDBClusterResult:
        pass

    def stop_db_instance(self, DBInstanceIdentifier: str, DBSnapshotIdentifier: str=None) -> StopDBInstanceResult:
        pass


class RDSDataService(BaseClient):
    class ExecuteSqlRequest(Mapping):
        pass

    class ExecuteSqlResponse(Mapping):
        pass

    def execute_sql(self, sqlStatements: str, dbClusterOrInstanceArn: str, awsSecretStoreArn: str, database: str=None, schema: str=None) -> ExecuteSqlResponse:
        pass


class Redshift(BaseClient):
    class AcceptReservedNodeExchangeInputMessage(Mapping):
        pass

    class AcceptReservedNodeExchangeOutputMessage(Mapping):
        pass

    class AuthorizeClusterSecurityGroupIngressMessage(Mapping):
        pass

    class AuthorizeClusterSecurityGroupIngressResult(Mapping):
        pass

    class AuthorizeSnapshotAccessMessage(Mapping):
        pass

    class AuthorizeSnapshotAccessResult(Mapping):
        pass

    class BatchDeleteClusterSnapshotsRequest(Mapping):
        pass

    class BatchDeleteClusterSnapshotsResult(Mapping):
        pass

    class DeleteClusterSnapshotMessage(Mapping):
        pass

    class BatchModifyClusterSnapshotsMessage(Mapping):
        pass

    class BatchModifyClusterSnapshotsOutputMessage(Mapping):
        pass

    class String(object):
        pass

    class Boolean(object):
        pass

    class CancelResizeMessage(Mapping):
        pass

    class ResizeProgressMessage(Mapping):
        pass

    class CopyClusterSnapshotMessage(Mapping):
        pass

    class CopyClusterSnapshotResult(Mapping):
        pass

    class CreateClusterMessage(Mapping):
        pass

    class CreateClusterResult(Mapping):
        pass

    class BooleanOptional(object):
        pass

    class Tag(Mapping):
        pass

    class CreateClusterParameterGroupMessage(Mapping):
        pass

    class CreateClusterParameterGroupResult(Mapping):
        pass

    class CreateClusterSecurityGroupMessage(Mapping):
        pass

    class CreateClusterSecurityGroupResult(Mapping):
        pass

    class CreateClusterSnapshotMessage(Mapping):
        pass

    class CreateClusterSnapshotResult(Mapping):
        pass

    class CreateClusterSubnetGroupMessage(Mapping):
        pass

    class CreateClusterSubnetGroupResult(Mapping):
        pass

    class CreateEventSubscriptionMessage(Mapping):
        pass

    class CreateEventSubscriptionResult(Mapping):
        pass

    class CreateHsmClientCertificateMessage(Mapping):
        pass

    class CreateHsmClientCertificateResult(Mapping):
        pass

    class CreateHsmConfigurationMessage(Mapping):
        pass

    class CreateHsmConfigurationResult(Mapping):
        pass

    class CreateSnapshotCopyGrantMessage(Mapping):
        pass

    class CreateSnapshotCopyGrantResult(Mapping):
        pass

    class CreateSnapshotScheduleMessage(Mapping):
        pass

    class SnapshotSchedule(Mapping):
        pass

    class CreateTagsMessage(Mapping):
        pass

    class DeleteClusterMessage(Mapping):
        pass

    class DeleteClusterResult(Mapping):
        pass

    class DeleteClusterParameterGroupMessage(Mapping):
        pass

    class DeleteClusterSecurityGroupMessage(Mapping):
        pass

    class DeleteClusterSnapshotResult(Mapping):
        pass

    class DeleteClusterSubnetGroupMessage(Mapping):
        pass

    class DeleteEventSubscriptionMessage(Mapping):
        pass

    class DeleteHsmClientCertificateMessage(Mapping):
        pass

    class DeleteHsmConfigurationMessage(Mapping):
        pass

    class DeleteSnapshotCopyGrantMessage(Mapping):
        pass

    class DeleteSnapshotScheduleMessage(Mapping):
        pass

    class DeleteTagsMessage(Mapping):
        pass

    class DescribeAccountAttributesMessage(Mapping):
        pass

    class AccountAttributeList(Mapping):
        pass

    class DescribeClusterDbRevisionsMessage(Mapping):
        pass

    class ClusterDbRevisionsMessage(Mapping):
        pass

    class DescribeClusterParameterGroupsMessage(Mapping):
        pass

    class ClusterParameterGroupsMessage(Mapping):
        pass

    class DescribeClusterParametersMessage(Mapping):
        pass

    class ClusterParameterGroupDetails(Mapping):
        pass

    class DescribeClusterSecurityGroupsMessage(Mapping):
        pass

    class ClusterSecurityGroupMessage(Mapping):
        pass

    class DescribeClusterSnapshotsMessage(Mapping):
        pass

    class SnapshotMessage(Mapping):
        pass

    class TStamp(object):
        pass

    class SnapshotSortingEntity(Mapping):
        pass

    class DescribeClusterSubnetGroupsMessage(Mapping):
        pass

    class ClusterSubnetGroupMessage(Mapping):
        pass

    class DescribeClusterTracksMessage(Mapping):
        pass

    class TrackListMessage(Mapping):
        pass

    class DescribeClusterVersionsMessage(Mapping):
        pass

    class ClusterVersionsMessage(Mapping):
        pass

    class DescribeClustersMessage(Mapping):
        pass

    class ClustersMessage(Mapping):
        pass

    class DescribeDefaultClusterParametersMessage(Mapping):
        pass

    class DescribeDefaultClusterParametersResult(Mapping):
        pass

    class DescribeEventCategoriesMessage(Mapping):
        pass

    class EventCategoriesMessage(Mapping):
        pass

    class DescribeEventSubscriptionsMessage(Mapping):
        pass

    class EventSubscriptionsMessage(Mapping):
        pass

    class DescribeEventsMessage(Mapping):
        pass

    class EventsMessage(Mapping):
        pass

    class DescribeHsmClientCertificatesMessage(Mapping):
        pass

    class HsmClientCertificateMessage(Mapping):
        pass

    class DescribeHsmConfigurationsMessage(Mapping):
        pass

    class HsmConfigurationMessage(Mapping):
        pass

    class DescribeLoggingStatusMessage(Mapping):
        pass

    class LoggingStatus(Mapping):
        pass

    class DescribeOrderableClusterOptionsMessage(Mapping):
        pass

    class OrderableClusterOptionsMessage(Mapping):
        pass

    class DescribeReservedNodeOfferingsMessage(Mapping):
        pass

    class ReservedNodeOfferingsMessage(Mapping):
        pass

    class DescribeReservedNodesMessage(Mapping):
        pass

    class ReservedNodesMessage(Mapping):
        pass

    class DescribeResizeMessage(Mapping):
        pass

    class DescribeSnapshotCopyGrantsMessage(Mapping):
        pass

    class SnapshotCopyGrantMessage(Mapping):
        pass

    class DescribeSnapshotSchedulesMessage(Mapping):
        pass

    class DescribeSnapshotSchedulesOutputMessage(Mapping):
        pass

    class CustomerStorageMessage(Mapping):
        pass

    class DescribeTableRestoreStatusMessage(Mapping):
        pass

    class TableRestoreStatusMessage(Mapping):
        pass

    class DescribeTagsMessage(Mapping):
        pass

    class TaggedResourceListMessage(Mapping):
        pass

    class DisableLoggingMessage(Mapping):
        pass

    class DisableSnapshotCopyMessage(Mapping):
        pass

    class DisableSnapshotCopyResult(Mapping):
        pass

    class EnableLoggingMessage(Mapping):
        pass

    class EnableSnapshotCopyMessage(Mapping):
        pass

    class EnableSnapshotCopyResult(Mapping):
        pass

    class GetClusterCredentialsMessage(Mapping):
        pass

    class ClusterCredentials(Mapping):
        pass

    class GetReservedNodeExchangeOfferingsInputMessage(Mapping):
        pass

    class GetReservedNodeExchangeOfferingsOutputMessage(Mapping):
        pass

    class ModifyClusterMessage(Mapping):
        pass

    class ModifyClusterResult(Mapping):
        pass

    class ModifyClusterDbRevisionMessage(Mapping):
        pass

    class ModifyClusterDbRevisionResult(Mapping):
        pass

    class ModifyClusterIamRolesMessage(Mapping):
        pass

    class ModifyClusterIamRolesResult(Mapping):
        pass

    class ModifyClusterMaintenanceMessage(Mapping):
        pass

    class ModifyClusterMaintenanceResult(Mapping):
        pass

    class ModifyClusterParameterGroupMessage(Mapping):
        pass

    class ClusterParameterGroupNameMessage(Mapping):
        pass

    class Parameter(Mapping):
        pass

    class ModifyClusterSnapshotMessage(Mapping):
        pass

    class ModifyClusterSnapshotResult(Mapping):
        pass

    class ModifyClusterSnapshotScheduleMessage(Mapping):
        pass

    class ModifyClusterSubnetGroupMessage(Mapping):
        pass

    class ModifyClusterSubnetGroupResult(Mapping):
        pass

    class ModifyEventSubscriptionMessage(Mapping):
        pass

    class ModifyEventSubscriptionResult(Mapping):
        pass

    class ModifySnapshotCopyRetentionPeriodMessage(Mapping):
        pass

    class ModifySnapshotCopyRetentionPeriodResult(Mapping):
        pass

    class ModifySnapshotScheduleMessage(Mapping):
        pass

    class PurchaseReservedNodeOfferingMessage(Mapping):
        pass

    class PurchaseReservedNodeOfferingResult(Mapping):
        pass

    class RebootClusterMessage(Mapping):
        pass

    class RebootClusterResult(Mapping):
        pass

    class ResetClusterParameterGroupMessage(Mapping):
        pass

    class ResizeClusterMessage(Mapping):
        pass

    class ResizeClusterResult(Mapping):
        pass

    class RestoreFromClusterSnapshotMessage(Mapping):
        pass

    class RestoreFromClusterSnapshotResult(Mapping):
        pass

    class RestoreTableFromClusterSnapshotMessage(Mapping):
        pass

    class RestoreTableFromClusterSnapshotResult(Mapping):
        pass

    class RevokeClusterSecurityGroupIngressMessage(Mapping):
        pass

    class RevokeClusterSecurityGroupIngressResult(Mapping):
        pass

    class RevokeSnapshotAccessMessage(Mapping):
        pass

    class RevokeSnapshotAccessResult(Mapping):
        pass

    class RotateEncryptionKeyMessage(Mapping):
        pass

    class RotateEncryptionKeyResult(Mapping):
        pass

    def accept_reserved_node_exchange(self, TargetReservedNodeOfferingId: str, ReservedNodeId: str) -> AcceptReservedNodeExchangeOutputMessage:
        pass

    def authorize_cluster_security_group_ingress(self, ClusterSecurityGroupName: str, CIDRIP: str=None, EC2SecurityGroupName: str=None, EC2SecurityGroupOwnerId: str=None) -> AuthorizeClusterSecurityGroupIngressResult:
        pass

    def authorize_snapshot_access(self, AccountWithRestoreAccess: str, SnapshotIdentifier: str, SnapshotClusterIdentifier: str=None) -> AuthorizeSnapshotAccessResult:
        pass

    def batch_delete_cluster_snapshots(self, Identifiers: List[DeleteClusterSnapshotMessage]) -> BatchDeleteClusterSnapshotsResult:
        pass

    def batch_modify_cluster_snapshots(self, SnapshotIdentifierList: List[String], ManualSnapshotRetentionPeriod: int=None, Force: Boolean=None) -> BatchModifyClusterSnapshotsOutputMessage:
        pass

    def cancel_resize(self, ClusterIdentifier: str) -> ResizeProgressMessage:
        pass

    def copy_cluster_snapshot(self, TargetSnapshotIdentifier: str, SourceSnapshotIdentifier: str, SourceSnapshotClusterIdentifier: str=None, ManualSnapshotRetentionPeriod: int=None) -> CopyClusterSnapshotResult:
        pass

    def create_cluster(self, MasterUserPassword: str, MasterUsername: str, NodeType: str, ClusterIdentifier: str, DBName: str=None, ClusterType: str=None, ClusterSecurityGroups: List[String]=None, VpcSecurityGroupIds: List[String]=None, ClusterSubnetGroupName: str=None, AvailabilityZone: str=None, PreferredMaintenanceWindow: str=None, ClusterParameterGroupName: str=None, AutomatedSnapshotRetentionPeriod: int=None, ManualSnapshotRetentionPeriod: int=None, Port: int=None, ClusterVersion: str=None, AllowVersionUpgrade: BooleanOptional=None, NumberOfNodes: int=None, PubliclyAccessible: BooleanOptional=None, Encrypted: BooleanOptional=None, HsmClientCertificateIdentifier: str=None, HsmConfigurationIdentifier: str=None, ElasticIp: str=None, Tags: List[Tag]=None, KmsKeyId: str=None, EnhancedVpcRouting: BooleanOptional=None, AdditionalInfo: str=None, IamRoles: List[String]=None, MaintenanceTrackName: str=None, SnapshotScheduleIdentifier: str=None) -> CreateClusterResult:
        pass

    def create_cluster_parameter_group(self, Description: str, ParameterGroupFamily: str, ParameterGroupName: str, Tags: List[Tag]=None) -> CreateClusterParameterGroupResult:
        pass

    def create_cluster_security_group(self, Description: str, ClusterSecurityGroupName: str, Tags: List[Tag]=None) -> CreateClusterSecurityGroupResult:
        pass

    def create_cluster_snapshot(self, ClusterIdentifier: str, SnapshotIdentifier: str, ManualSnapshotRetentionPeriod: int=None, Tags: List[Tag]=None) -> CreateClusterSnapshotResult:
        pass

    def create_cluster_subnet_group(self, SubnetIds: List[String], Description: str, ClusterSubnetGroupName: str, Tags: List[Tag]=None) -> CreateClusterSubnetGroupResult:
        pass

    def create_event_subscription(self, SnsTopicArn: str, SubscriptionName: str, SourceType: str=None, SourceIds: List[String]=None, EventCategories: List[String]=None, Severity: str=None, Enabled: BooleanOptional=None, Tags: List[Tag]=None) -> CreateEventSubscriptionResult:
        pass

    def create_hsm_client_certificate(self, HsmClientCertificateIdentifier: str, Tags: List[Tag]=None) -> CreateHsmClientCertificateResult:
        pass

    def create_hsm_configuration(self, HsmServerPublicCertificate: str, HsmPartitionPassword: str, HsmPartitionName: str, HsmIpAddress: str, Description: str, HsmConfigurationIdentifier: str, Tags: List[Tag]=None) -> CreateHsmConfigurationResult:
        pass

    def create_snapshot_copy_grant(self, SnapshotCopyGrantName: str, KmsKeyId: str=None, Tags: List[Tag]=None) -> CreateSnapshotCopyGrantResult:
        pass

    def create_snapshot_schedule(self, ScheduleDefinitions: List[String]=None, ScheduleIdentifier: str=None, ScheduleDescription: str=None, Tags: List[Tag]=None, DryRun: BooleanOptional=None, NextInvocations: int=None) -> SnapshotSchedule:
        pass

    def create_tags(self, Tags: List[Tag], ResourceName: str):
        pass

    def delete_cluster(self, ClusterIdentifier: str, SkipFinalClusterSnapshot: Boolean=None, FinalClusterSnapshotIdentifier: str=None, FinalClusterSnapshotRetentionPeriod: int=None) -> DeleteClusterResult:
        pass

    def delete_cluster_parameter_group(self, ParameterGroupName: str):
        pass

    def delete_cluster_security_group(self, ClusterSecurityGroupName: str):
        pass

    def delete_cluster_snapshot(self, SnapshotIdentifier: str, SnapshotClusterIdentifier: str=None) -> DeleteClusterSnapshotResult:
        pass

    def delete_cluster_subnet_group(self, ClusterSubnetGroupName: str):
        pass

    def delete_event_subscription(self, SubscriptionName: str):
        pass

    def delete_hsm_client_certificate(self, HsmClientCertificateIdentifier: str):
        pass

    def delete_hsm_configuration(self, HsmConfigurationIdentifier: str):
        pass

    def delete_snapshot_copy_grant(self, SnapshotCopyGrantName: str):
        pass

    def delete_snapshot_schedule(self, ScheduleIdentifier: str):
        pass

    def delete_tags(self, TagKeys: List[String], ResourceName: str):
        pass

    def describe_account_attributes(self, AttributeNames: List[String]=None) -> AccountAttributeList:
        pass

    def describe_cluster_db_revisions(self, ClusterIdentifier: str=None, MaxRecords: int=None, Marker: str=None) -> ClusterDbRevisionsMessage:
        pass

    def describe_cluster_parameter_groups(self, ParameterGroupName: str=None, MaxRecords: int=None, Marker: str=None, TagKeys: List[String]=None, TagValues: List[String]=None) -> ClusterParameterGroupsMessage:
        pass

    def describe_cluster_parameters(self, ParameterGroupName: str, Source: str=None, MaxRecords: int=None, Marker: str=None) -> ClusterParameterGroupDetails:
        pass

    def describe_cluster_security_groups(self, ClusterSecurityGroupName: str=None, MaxRecords: int=None, Marker: str=None, TagKeys: List[String]=None, TagValues: List[String]=None) -> ClusterSecurityGroupMessage:
        pass

    def describe_cluster_snapshots(self, ClusterIdentifier: str=None, SnapshotIdentifier: str=None, SnapshotType: str=None, StartTime: TStamp=None, EndTime: TStamp=None, MaxRecords: int=None, Marker: str=None, OwnerAccount: str=None, TagKeys: List[String]=None, TagValues: List[String]=None, ClusterExists: BooleanOptional=None, SortingEntities: List[SnapshotSortingEntity]=None) -> SnapshotMessage:
        pass

    def describe_cluster_subnet_groups(self, ClusterSubnetGroupName: str=None, MaxRecords: int=None, Marker: str=None, TagKeys: List[String]=None, TagValues: List[String]=None) -> ClusterSubnetGroupMessage:
        pass

    def describe_cluster_tracks(self, MaintenanceTrackName: str=None, MaxRecords: int=None, Marker: str=None) -> TrackListMessage:
        pass

    def describe_cluster_versions(self, ClusterVersion: str=None, ClusterParameterGroupFamily: str=None, MaxRecords: int=None, Marker: str=None) -> ClusterVersionsMessage:
        pass

    def describe_clusters(self, ClusterIdentifier: str=None, MaxRecords: int=None, Marker: str=None, TagKeys: List[String]=None, TagValues: List[String]=None) -> ClustersMessage:
        pass

    def describe_default_cluster_parameters(self, ParameterGroupFamily: str, MaxRecords: int=None, Marker: str=None) -> DescribeDefaultClusterParametersResult:
        pass

    def describe_event_categories(self, SourceType: str=None) -> EventCategoriesMessage:
        pass

    def describe_event_subscriptions(self, SubscriptionName: str=None, MaxRecords: int=None, Marker: str=None, TagKeys: List[String]=None, TagValues: List[String]=None) -> EventSubscriptionsMessage:
        pass

    def describe_events(self, SourceIdentifier: str=None, SourceType: str=None, StartTime: TStamp=None, EndTime: TStamp=None, Duration: int=None, MaxRecords: int=None, Marker: str=None) -> EventsMessage:
        pass

    def describe_hsm_client_certificates(self, HsmClientCertificateIdentifier: str=None, MaxRecords: int=None, Marker: str=None, TagKeys: List[String]=None, TagValues: List[String]=None) -> HsmClientCertificateMessage:
        pass

    def describe_hsm_configurations(self, HsmConfigurationIdentifier: str=None, MaxRecords: int=None, Marker: str=None, TagKeys: List[String]=None, TagValues: List[String]=None) -> HsmConfigurationMessage:
        pass

    def describe_logging_status(self, ClusterIdentifier: str) -> LoggingStatus:
        pass

    def describe_orderable_cluster_options(self, ClusterVersion: str=None, NodeType: str=None, MaxRecords: int=None, Marker: str=None) -> OrderableClusterOptionsMessage:
        pass

    def describe_reserved_node_offerings(self, ReservedNodeOfferingId: str=None, MaxRecords: int=None, Marker: str=None) -> ReservedNodeOfferingsMessage:
        pass

    def describe_reserved_nodes(self, ReservedNodeId: str=None, MaxRecords: int=None, Marker: str=None) -> ReservedNodesMessage:
        pass

    def describe_resize(self, ClusterIdentifier: str) -> ResizeProgressMessage:
        pass

    def describe_snapshot_copy_grants(self, SnapshotCopyGrantName: str=None, MaxRecords: int=None, Marker: str=None, TagKeys: List[String]=None, TagValues: List[String]=None) -> SnapshotCopyGrantMessage:
        pass

    def describe_snapshot_schedules(self, ClusterIdentifier: str=None, ScheduleIdentifier: str=None, TagKeys: List[String]=None, TagValues: List[String]=None, Marker: str=None, MaxRecords: int=None) -> DescribeSnapshotSchedulesOutputMessage:
        pass

    def describe_storage(self) -> CustomerStorageMessage:
        pass

    def describe_table_restore_status(self, ClusterIdentifier: str=None, TableRestoreRequestId: str=None, MaxRecords: int=None, Marker: str=None) -> TableRestoreStatusMessage:
        pass

    def describe_tags(self, ResourceName: str=None, ResourceType: str=None, MaxRecords: int=None, Marker: str=None, TagKeys: List[String]=None, TagValues: List[String]=None) -> TaggedResourceListMessage:
        pass

    def disable_logging(self, ClusterIdentifier: str) -> LoggingStatus:
        pass

    def disable_snapshot_copy(self, ClusterIdentifier: str) -> DisableSnapshotCopyResult:
        pass

    def enable_logging(self, BucketName: str, ClusterIdentifier: str, S3KeyPrefix: str=None) -> LoggingStatus:
        pass

    def enable_snapshot_copy(self, DestinationRegion: str, ClusterIdentifier: str, RetentionPeriod: int=None, SnapshotCopyGrantName: str=None, ManualSnapshotRetentionPeriod: int=None) -> EnableSnapshotCopyResult:
        pass

    def get_cluster_credentials(self, ClusterIdentifier: str, DbUser: str, DbName: str=None, DurationSeconds: int=None, AutoCreate: BooleanOptional=None, DbGroups: List[String]=None) -> ClusterCredentials:
        pass

    def get_reserved_node_exchange_offerings(self, ReservedNodeId: str, MaxRecords: int=None, Marker: str=None) -> GetReservedNodeExchangeOfferingsOutputMessage:
        pass

    def modify_cluster(self, ClusterIdentifier: str, ClusterType: str=None, NodeType: str=None, NumberOfNodes: int=None, ClusterSecurityGroups: List[String]=None, VpcSecurityGroupIds: List[String]=None, MasterUserPassword: str=None, ClusterParameterGroupName: str=None, AutomatedSnapshotRetentionPeriod: int=None, ManualSnapshotRetentionPeriod: int=None, PreferredMaintenanceWindow: str=None, ClusterVersion: str=None, AllowVersionUpgrade: BooleanOptional=None, HsmClientCertificateIdentifier: str=None, HsmConfigurationIdentifier: str=None, NewClusterIdentifier: str=None, PubliclyAccessible: BooleanOptional=None, ElasticIp: str=None, EnhancedVpcRouting: BooleanOptional=None, MaintenanceTrackName: str=None, Encrypted: BooleanOptional=None, KmsKeyId: str=None) -> ModifyClusterResult:
        pass

    def modify_cluster_db_revision(self, RevisionTarget: str, ClusterIdentifier: str) -> ModifyClusterDbRevisionResult:
        pass

    def modify_cluster_iam_roles(self, ClusterIdentifier: str, AddIamRoles: List[String]=None, RemoveIamRoles: List[String]=None) -> ModifyClusterIamRolesResult:
        pass

    def modify_cluster_maintenance(self, ClusterIdentifier: str, DeferMaintenance: BooleanOptional=None, DeferMaintenanceIdentifier: str=None, DeferMaintenanceStartTime: TStamp=None, DeferMaintenanceEndTime: TStamp=None, DeferMaintenanceDuration: int=None) -> ModifyClusterMaintenanceResult:
        pass

    def modify_cluster_parameter_group(self, Parameters: List[Parameter], ParameterGroupName: str) -> ClusterParameterGroupNameMessage:
        pass

    def modify_cluster_snapshot(self, SnapshotIdentifier: str, ManualSnapshotRetentionPeriod: int=None, Force: Boolean=None) -> ModifyClusterSnapshotResult:
        pass

    def modify_cluster_snapshot_schedule(self, ClusterIdentifier: str, ScheduleIdentifier: str=None, DisassociateSchedule: BooleanOptional=None):
        pass

    def modify_cluster_subnet_group(self, SubnetIds: List[String], ClusterSubnetGroupName: str, Description: str=None) -> ModifyClusterSubnetGroupResult:
        pass

    def modify_event_subscription(self, SubscriptionName: str, SnsTopicArn: str=None, SourceType: str=None, SourceIds: List[String]=None, EventCategories: List[String]=None, Severity: str=None, Enabled: BooleanOptional=None) -> ModifyEventSubscriptionResult:
        pass

    def modify_snapshot_copy_retention_period(self, RetentionPeriod: int, ClusterIdentifier: str, Manual: Boolean=None) -> ModifySnapshotCopyRetentionPeriodResult:
        pass

    def modify_snapshot_schedule(self, ScheduleDefinitions: List[String], ScheduleIdentifier: str) -> SnapshotSchedule:
        pass

    def purchase_reserved_node_offering(self, ReservedNodeOfferingId: str, NodeCount: int=None) -> PurchaseReservedNodeOfferingResult:
        pass

    def reboot_cluster(self, ClusterIdentifier: str) -> RebootClusterResult:
        pass

    def reset_cluster_parameter_group(self, ParameterGroupName: str, ResetAllParameters: Boolean=None, Parameters: List[Parameter]=None) -> ClusterParameterGroupNameMessage:
        pass

    def resize_cluster(self, NumberOfNodes: int, ClusterIdentifier: str, ClusterType: str=None, NodeType: str=None, Classic: BooleanOptional=None) -> ResizeClusterResult:
        pass

    def restore_from_cluster_snapshot(self, SnapshotIdentifier: str, ClusterIdentifier: str, SnapshotClusterIdentifier: str=None, Port: int=None, AvailabilityZone: str=None, AllowVersionUpgrade: BooleanOptional=None, ClusterSubnetGroupName: str=None, PubliclyAccessible: BooleanOptional=None, OwnerAccount: str=None, HsmClientCertificateIdentifier: str=None, HsmConfigurationIdentifier: str=None, ElasticIp: str=None, ClusterParameterGroupName: str=None, ClusterSecurityGroups: List[String]=None, VpcSecurityGroupIds: List[String]=None, PreferredMaintenanceWindow: str=None, AutomatedSnapshotRetentionPeriod: int=None, ManualSnapshotRetentionPeriod: int=None, KmsKeyId: str=None, NodeType: str=None, EnhancedVpcRouting: BooleanOptional=None, AdditionalInfo: str=None, IamRoles: List[String]=None, MaintenanceTrackName: str=None, SnapshotScheduleIdentifier: str=None) -> RestoreFromClusterSnapshotResult:
        pass

    def restore_table_from_cluster_snapshot(self, NewTableName: str, SourceTableName: str, SourceDatabaseName: str, SnapshotIdentifier: str, ClusterIdentifier: str, SourceSchemaName: str=None, TargetDatabaseName: str=None, TargetSchemaName: str=None) -> RestoreTableFromClusterSnapshotResult:
        pass

    def revoke_cluster_security_group_ingress(self, ClusterSecurityGroupName: str, CIDRIP: str=None, EC2SecurityGroupName: str=None, EC2SecurityGroupOwnerId: str=None) -> RevokeClusterSecurityGroupIngressResult:
        pass

    def revoke_snapshot_access(self, AccountWithRestoreAccess: str, SnapshotIdentifier: str, SnapshotClusterIdentifier: str=None) -> RevokeSnapshotAccessResult:
        pass

    def rotate_encryption_key(self, ClusterIdentifier: str) -> RotateEncryptionKeyResult:
        pass


class Rekognition(BaseClient):
    class CompareFacesRequest(Mapping):
        pass

    class CompareFacesResponse(Mapping):
        pass

    class Image(Mapping):
        pass

    class Percent(object):
        pass

    class CreateCollectionRequest(Mapping):
        pass

    class CreateCollectionResponse(Mapping):
        pass

    class CreateStreamProcessorRequest(Mapping):
        pass

    class CreateStreamProcessorResponse(Mapping):
        pass

    class StreamProcessorInput(Mapping):
        pass

    class StreamProcessorOutput(Mapping):
        pass

    class StreamProcessorSettings(Mapping):
        pass

    class DeleteCollectionRequest(Mapping):
        pass

    class DeleteCollectionResponse(Mapping):
        pass

    class DeleteFacesRequest(Mapping):
        pass

    class DeleteFacesResponse(Mapping):
        pass

    class FaceId(object):
        pass

    class DeleteStreamProcessorRequest(Mapping):
        pass

    class DeleteStreamProcessorResponse(Mapping):
        pass

    class DescribeCollectionRequest(Mapping):
        pass

    class DescribeCollectionResponse(Mapping):
        pass

    class DescribeStreamProcessorRequest(Mapping):
        pass

    class DescribeStreamProcessorResponse(Mapping):
        pass

    class DetectFacesRequest(Mapping):
        pass

    class DetectFacesResponse(Mapping):
        pass

    class Attribute(object):
        pass

    class DetectLabelsRequest(Mapping):
        pass

    class DetectLabelsResponse(Mapping):
        pass

    class DetectModerationLabelsRequest(Mapping):
        pass

    class DetectModerationLabelsResponse(Mapping):
        pass

    class DetectTextRequest(Mapping):
        pass

    class DetectTextResponse(Mapping):
        pass

    class GetCelebrityInfoRequest(Mapping):
        pass

    class GetCelebrityInfoResponse(Mapping):
        pass

    class GetCelebrityRecognitionRequest(Mapping):
        pass

    class GetCelebrityRecognitionResponse(Mapping):
        pass

    class GetContentModerationRequest(Mapping):
        pass

    class GetContentModerationResponse(Mapping):
        pass

    class GetFaceDetectionRequest(Mapping):
        pass

    class GetFaceDetectionResponse(Mapping):
        pass

    class GetFaceSearchRequest(Mapping):
        pass

    class GetFaceSearchResponse(Mapping):
        pass

    class GetLabelDetectionRequest(Mapping):
        pass

    class GetLabelDetectionResponse(Mapping):
        pass

    class GetPersonTrackingRequest(Mapping):
        pass

    class GetPersonTrackingResponse(Mapping):
        pass

    class IndexFacesRequest(Mapping):
        pass

    class IndexFacesResponse(Mapping):
        pass

    class ListCollectionsRequest(Mapping):
        pass

    class ListCollectionsResponse(Mapping):
        pass

    class ListFacesRequest(Mapping):
        pass

    class ListFacesResponse(Mapping):
        pass

    class ListStreamProcessorsRequest(Mapping):
        pass

    class ListStreamProcessorsResponse(Mapping):
        pass

    class RecognizeCelebritiesRequest(Mapping):
        pass

    class RecognizeCelebritiesResponse(Mapping):
        pass

    class SearchFacesRequest(Mapping):
        pass

    class SearchFacesResponse(Mapping):
        pass

    class SearchFacesByImageRequest(Mapping):
        pass

    class SearchFacesByImageResponse(Mapping):
        pass

    class StartCelebrityRecognitionRequest(Mapping):
        pass

    class StartCelebrityRecognitionResponse(Mapping):
        pass

    class Video(Mapping):
        pass

    class NotificationChannel(Mapping):
        pass

    class StartContentModerationRequest(Mapping):
        pass

    class StartContentModerationResponse(Mapping):
        pass

    class StartFaceDetectionRequest(Mapping):
        pass

    class StartFaceDetectionResponse(Mapping):
        pass

    class StartFaceSearchRequest(Mapping):
        pass

    class StartFaceSearchResponse(Mapping):
        pass

    class StartLabelDetectionRequest(Mapping):
        pass

    class StartLabelDetectionResponse(Mapping):
        pass

    class StartPersonTrackingRequest(Mapping):
        pass

    class StartPersonTrackingResponse(Mapping):
        pass

    class StartStreamProcessorRequest(Mapping):
        pass

    class StartStreamProcessorResponse(Mapping):
        pass

    class StopStreamProcessorRequest(Mapping):
        pass

    class StopStreamProcessorResponse(Mapping):
        pass

    def compare_faces(self, TargetImage: Image, SourceImage: Image, SimilarityThreshold: Percent=None) -> CompareFacesResponse:
        pass

    def create_collection(self, CollectionId: str) -> CreateCollectionResponse:
        pass

    def create_stream_processor(self, RoleArn: str, Settings: StreamProcessorSettings, Name: str, Output: StreamProcessorOutput, Input: StreamProcessorInput) -> CreateStreamProcessorResponse:
        pass

    def delete_collection(self, CollectionId: str) -> DeleteCollectionResponse:
        pass

    def delete_faces(self, FaceIds: List[FaceId], CollectionId: str) -> DeleteFacesResponse:
        pass

    def delete_stream_processor(self, Name: str) -> DeleteStreamProcessorResponse:
        pass

    def describe_collection(self, CollectionId: str) -> DescribeCollectionResponse:
        pass

    def describe_stream_processor(self, Name: str) -> DescribeStreamProcessorResponse:
        pass

    def detect_faces(self, Image: Image, Attributes: List[Attribute]=None) -> DetectFacesResponse:
        pass

    def detect_labels(self, Image: Image, MaxLabels: int=None, MinConfidence: Percent=None) -> DetectLabelsResponse:
        pass

    def detect_moderation_labels(self, Image: Image, MinConfidence: Percent=None) -> DetectModerationLabelsResponse:
        pass

    def detect_text(self, Image: Image) -> DetectTextResponse:
        pass

    def get_celebrity_info(self, Id: str) -> GetCelebrityInfoResponse:
        pass

    def get_celebrity_recognition(self, JobId: str, MaxResults: int=None, NextToken: str=None, SortBy: str=None) -> GetCelebrityRecognitionResponse:
        pass

    def get_content_moderation(self, JobId: str, MaxResults: int=None, NextToken: str=None, SortBy: str=None) -> GetContentModerationResponse:
        pass

    def get_face_detection(self, JobId: str, MaxResults: int=None, NextToken: str=None) -> GetFaceDetectionResponse:
        pass

    def get_face_search(self, JobId: str, MaxResults: int=None, NextToken: str=None, SortBy: str=None) -> GetFaceSearchResponse:
        pass

    def get_label_detection(self, JobId: str, MaxResults: int=None, NextToken: str=None, SortBy: str=None) -> GetLabelDetectionResponse:
        pass

    def get_person_tracking(self, JobId: str, MaxResults: int=None, NextToken: str=None, SortBy: str=None) -> GetPersonTrackingResponse:
        pass

    def index_faces(self, Image: Image, CollectionId: str, ExternalImageId: str=None, DetectionAttributes: List[Attribute]=None, MaxFaces: int=None, QualityFilter: str=None) -> IndexFacesResponse:
        pass

    def list_collections(self, NextToken: str=None, MaxResults: int=None) -> ListCollectionsResponse:
        pass

    def list_faces(self, CollectionId: str, NextToken: str=None, MaxResults: int=None) -> ListFacesResponse:
        pass

    def list_stream_processors(self, NextToken: str=None, MaxResults: int=None) -> ListStreamProcessorsResponse:
        pass

    def recognize_celebrities(self, Image: Image) -> RecognizeCelebritiesResponse:
        pass

    def search_faces(self, FaceId: str, CollectionId: str, MaxFaces: int=None, FaceMatchThreshold: Percent=None) -> SearchFacesResponse:
        pass

    def search_faces_by_image(self, Image: Image, CollectionId: str, MaxFaces: int=None, FaceMatchThreshold: Percent=None) -> SearchFacesByImageResponse:
        pass

    def start_celebrity_recognition(self, Video: Video, ClientRequestToken: str=None, NotificationChannel: NotificationChannel=None, JobTag: str=None) -> StartCelebrityRecognitionResponse:
        pass

    def start_content_moderation(self, Video: Video, MinConfidence: Percent=None, ClientRequestToken: str=None, NotificationChannel: NotificationChannel=None, JobTag: str=None) -> StartContentModerationResponse:
        pass

    def start_face_detection(self, Video: Video, ClientRequestToken: str=None, NotificationChannel: NotificationChannel=None, FaceAttributes: str=None, JobTag: str=None) -> StartFaceDetectionResponse:
        pass

    def start_face_search(self, CollectionId: str, Video: Video, ClientRequestToken: str=None, FaceMatchThreshold: Percent=None, NotificationChannel: NotificationChannel=None, JobTag: str=None) -> StartFaceSearchResponse:
        pass

    def start_label_detection(self, Video: Video, ClientRequestToken: str=None, MinConfidence: Percent=None, NotificationChannel: NotificationChannel=None, JobTag: str=None) -> StartLabelDetectionResponse:
        pass

    def start_person_tracking(self, Video: Video, ClientRequestToken: str=None, NotificationChannel: NotificationChannel=None, JobTag: str=None) -> StartPersonTrackingResponse:
        pass

    def start_stream_processor(self, Name: str) -> StartStreamProcessorResponse:
        pass

    def stop_stream_processor(self, Name: str) -> StopStreamProcessorResponse:
        pass


class ResourceGroups(BaseClient):
    class CreateGroupInput(Mapping):
        pass

    class CreateGroupOutput(Mapping):
        pass

    class ResourceQuery(Mapping):
        pass

    class Tags(object):
        pass

    class DeleteGroupInput(Mapping):
        pass

    class DeleteGroupOutput(Mapping):
        pass

    class GetGroupInput(Mapping):
        pass

    class GetGroupOutput(Mapping):
        pass

    class GetGroupQueryInput(Mapping):
        pass

    class GetGroupQueryOutput(Mapping):
        pass

    class GetTagsInput(Mapping):
        pass

    class GetTagsOutput(Mapping):
        pass

    class ListGroupResourcesInput(Mapping):
        pass

    class ListGroupResourcesOutput(Mapping):
        pass

    class ResourceFilter(Mapping):
        pass

    class ListGroupsInput(Mapping):
        pass

    class ListGroupsOutput(Mapping):
        pass

    class GroupFilter(Mapping):
        pass

    class SearchResourcesInput(Mapping):
        pass

    class SearchResourcesOutput(Mapping):
        pass

    class TagInput(Mapping):
        pass

    class TagOutput(Mapping):
        pass

    class UntagInput(Mapping):
        pass

    class UntagOutput(Mapping):
        pass

    class TagKey(object):
        pass

    class UpdateGroupInput(Mapping):
        pass

    class UpdateGroupOutput(Mapping):
        pass

    class UpdateGroupQueryInput(Mapping):
        pass

    class UpdateGroupQueryOutput(Mapping):
        pass

    def create_group(self, ResourceQuery: ResourceQuery, Name: str, Description: str=None, Tags: Tags=None) -> CreateGroupOutput:
        pass

    def delete_group(self, GroupName: str) -> DeleteGroupOutput:
        pass

    def get_group(self, GroupName: str) -> GetGroupOutput:
        pass

    def get_group_query(self, GroupName: str) -> GetGroupQueryOutput:
        pass

    def get_tags(self, Arn: str) -> GetTagsOutput:
        pass

    def list_group_resources(self, GroupName: str, Filters: List[ResourceFilter]=None, MaxResults: int=None, NextToken: str=None) -> ListGroupResourcesOutput:
        pass

    def list_groups(self, Filters: List[GroupFilter]=None, MaxResults: int=None, NextToken: str=None) -> ListGroupsOutput:
        pass

    def search_resources(self, ResourceQuery: ResourceQuery, MaxResults: int=None, NextToken: str=None) -> SearchResourcesOutput:
        pass

    def tag(self, Tags: Tags, Arn: str) -> TagOutput:
        pass

    def untag(self, Keys: List[TagKey], Arn: str) -> UntagOutput:
        pass

    def update_group(self, GroupName: str, Description: str=None) -> UpdateGroupOutput:
        pass

    def update_group_query(self, ResourceQuery: ResourceQuery, GroupName: str) -> UpdateGroupQueryOutput:
        pass


class ResourceGroupsTaggingAPI(BaseClient):
    class GetResourcesInput(Mapping):
        pass

    class GetResourcesOutput(Mapping):
        pass

    class TagFilter(Mapping):
        pass

    class AmazonResourceType(object):
        pass

    class GetTagKeysInput(Mapping):
        pass

    class GetTagKeysOutput(Mapping):
        pass

    class GetTagValuesInput(Mapping):
        pass

    class GetTagValuesOutput(Mapping):
        pass

    class TagResourcesInput(Mapping):
        pass

    class TagResourcesOutput(Mapping):
        pass

    class ResourceARN(object):
        pass

    class TagMap(object):
        pass

    class UntagResourcesInput(Mapping):
        pass

    class UntagResourcesOutput(Mapping):
        pass

    class TagKey(object):
        pass

    def get_resources(self, PaginationToken: str=None, TagFilters: List[TagFilter]=None, ResourcesPerPage: int=None, TagsPerPage: int=None, ResourceTypeFilters: List[AmazonResourceType]=None) -> GetResourcesOutput:
        pass

    def get_tag_keys(self, PaginationToken: str=None) -> GetTagKeysOutput:
        pass

    def get_tag_values(self, Key: str, PaginationToken: str=None) -> GetTagValuesOutput:
        pass

    def tag_resources(self, Tags: TagMap, ResourceARNList: List[ResourceARN]) -> TagResourcesOutput:
        pass

    def untag_resources(self, TagKeys: List[TagKey], ResourceARNList: List[ResourceARN]) -> UntagResourcesOutput:
        pass


class RoboMaker(BaseClient):
    class BatchDescribeSimulationJobRequest(Mapping):
        pass

    class BatchDescribeSimulationJobResponse(Mapping):
        pass

    class Arn(object):
        pass

    class CancelSimulationJobRequest(Mapping):
        pass

    class CancelSimulationJobResponse(Mapping):
        pass

    class CreateDeploymentJobRequest(Mapping):
        pass

    class CreateDeploymentJobResponse(Mapping):
        pass

    class DeploymentConfig(Mapping):
        pass

    class DeploymentApplicationConfig(Mapping):
        pass

    class CreateFleetRequest(Mapping):
        pass

    class CreateFleetResponse(Mapping):
        pass

    class CreateRobotRequest(Mapping):
        pass

    class CreateRobotResponse(Mapping):
        pass

    class CreateRobotApplicationRequest(Mapping):
        pass

    class CreateRobotApplicationResponse(Mapping):
        pass

    class SourceConfig(Mapping):
        pass

    class RobotSoftwareSuite(Mapping):
        pass

    class CreateRobotApplicationVersionRequest(Mapping):
        pass

    class CreateRobotApplicationVersionResponse(Mapping):
        pass

    class CreateSimulationApplicationRequest(Mapping):
        pass

    class CreateSimulationApplicationResponse(Mapping):
        pass

    class SimulationSoftwareSuite(Mapping):
        pass

    class RenderingEngine(Mapping):
        pass

    class CreateSimulationApplicationVersionRequest(Mapping):
        pass

    class CreateSimulationApplicationVersionResponse(Mapping):
        pass

    class CreateSimulationJobRequest(Mapping):
        pass

    class CreateSimulationJobResponse(Mapping):
        pass

    class OutputLocation(Mapping):
        pass

    class JobDuration(object):
        pass

    class RobotApplicationConfig(Mapping):
        pass

    class SimulationApplicationConfig(Mapping):
        pass

    class VPCConfig(Mapping):
        pass

    class DeleteFleetRequest(Mapping):
        pass

    class DeleteFleetResponse(Mapping):
        pass

    class DeleteRobotRequest(Mapping):
        pass

    class DeleteRobotResponse(Mapping):
        pass

    class DeleteRobotApplicationRequest(Mapping):
        pass

    class DeleteRobotApplicationResponse(Mapping):
        pass

    class DeleteSimulationApplicationRequest(Mapping):
        pass

    class DeleteSimulationApplicationResponse(Mapping):
        pass

    class DeregisterRobotRequest(Mapping):
        pass

    class DeregisterRobotResponse(Mapping):
        pass

    class DescribeDeploymentJobRequest(Mapping):
        pass

    class DescribeDeploymentJobResponse(Mapping):
        pass

    class DescribeFleetRequest(Mapping):
        pass

    class DescribeFleetResponse(Mapping):
        pass

    class DescribeRobotRequest(Mapping):
        pass

    class DescribeRobotResponse(Mapping):
        pass

    class DescribeRobotApplicationRequest(Mapping):
        pass

    class DescribeRobotApplicationResponse(Mapping):
        pass

    class DescribeSimulationApplicationRequest(Mapping):
        pass

    class DescribeSimulationApplicationResponse(Mapping):
        pass

    class DescribeSimulationJobRequest(Mapping):
        pass

    class DescribeSimulationJobResponse(Mapping):
        pass

    class ListDeploymentJobsRequest(Mapping):
        pass

    class ListDeploymentJobsResponse(Mapping):
        pass

    class Filter(Mapping):
        pass

    class ListFleetsRequest(Mapping):
        pass

    class ListFleetsResponse(Mapping):
        pass

    class ListRobotApplicationsRequest(Mapping):
        pass

    class ListRobotApplicationsResponse(Mapping):
        pass

    class ListRobotsRequest(Mapping):
        pass

    class ListRobotsResponse(Mapping):
        pass

    class ListSimulationApplicationsRequest(Mapping):
        pass

    class ListSimulationApplicationsResponse(Mapping):
        pass

    class ListSimulationJobsRequest(Mapping):
        pass

    class ListSimulationJobsResponse(Mapping):
        pass

    class RegisterRobotRequest(Mapping):
        pass

    class RegisterRobotResponse(Mapping):
        pass

    class RestartSimulationJobRequest(Mapping):
        pass

    class RestartSimulationJobResponse(Mapping):
        pass

    class SyncDeploymentJobRequest(Mapping):
        pass

    class SyncDeploymentJobResponse(Mapping):
        pass

    class UpdateRobotApplicationRequest(Mapping):
        pass

    class UpdateRobotApplicationResponse(Mapping):
        pass

    class UpdateSimulationApplicationRequest(Mapping):
        pass

    class UpdateSimulationApplicationResponse(Mapping):
        pass

    def batch_describe_simulation_job(self, jobs: List[Arn]) -> BatchDescribeSimulationJobResponse:
        pass

    def cancel_simulation_job(self, job: str) -> CancelSimulationJobResponse:
        pass

    def create_deployment_job(self, deploymentApplicationConfigs: List[DeploymentApplicationConfig], fleet: str, clientRequestToken: str, deploymentConfig: DeploymentConfig=None) -> CreateDeploymentJobResponse:
        pass

    def create_fleet(self, name: str) -> CreateFleetResponse:
        pass

    def create_robot(self, greengrassGroupId: str, architecture: str, name: str) -> CreateRobotResponse:
        pass

    def create_robot_application(self, robotSoftwareSuite: RobotSoftwareSuite, sources: List[SourceConfig], name: str) -> CreateRobotApplicationResponse:
        pass

    def create_robot_application_version(self, application: str, currentRevisionId: str=None) -> CreateRobotApplicationVersionResponse:
        pass

    def create_simulation_application(self, renderingEngine: RenderingEngine, robotSoftwareSuite: RobotSoftwareSuite, simulationSoftwareSuite: SimulationSoftwareSuite, sources: List[SourceConfig], name: str) -> CreateSimulationApplicationResponse:
        pass

    def create_simulation_application_version(self, application: str, currentRevisionId: str=None) -> CreateSimulationApplicationVersionResponse:
        pass

    def create_simulation_job(self, iamRole: str, maxJobDurationInSeconds: JobDuration, clientRequestToken: str=None, outputLocation: OutputLocation=None, failureBehavior: str=None, robotApplications: List[RobotApplicationConfig]=None, simulationApplications: List[SimulationApplicationConfig]=None, vpcConfig: VPCConfig=None) -> CreateSimulationJobResponse:
        pass

    def delete_fleet(self, fleet: str) -> DeleteFleetResponse:
        pass

    def delete_robot(self, robot: str) -> DeleteRobotResponse:
        pass

    def delete_robot_application(self, application: str, applicationVersion: str=None) -> DeleteRobotApplicationResponse:
        pass

    def delete_simulation_application(self, application: str, applicationVersion: str=None) -> DeleteSimulationApplicationResponse:
        pass

    def deregister_robot(self, robot: str, fleet: str) -> DeregisterRobotResponse:
        pass

    def describe_deployment_job(self, job: str) -> DescribeDeploymentJobResponse:
        pass

    def describe_fleet(self, fleet: str) -> DescribeFleetResponse:
        pass

    def describe_robot(self, robot: str) -> DescribeRobotResponse:
        pass

    def describe_robot_application(self, application: str, applicationVersion: str=None) -> DescribeRobotApplicationResponse:
        pass

    def describe_simulation_application(self, application: str, applicationVersion: str=None) -> DescribeSimulationApplicationResponse:
        pass

    def describe_simulation_job(self, job: str) -> DescribeSimulationJobResponse:
        pass

    def list_deployment_jobs(self, filters: List[Filter]=None, nextToken: str=None, maxResults: int=None) -> ListDeploymentJobsResponse:
        pass

    def list_fleets(self, nextToken: str=None, maxResults: int=None, filters: List[Filter]=None) -> ListFleetsResponse:
        pass

    def list_robot_applications(self, versionQualifier: str=None, nextToken: str=None, maxResults: int=None, filters: List[Filter]=None) -> ListRobotApplicationsResponse:
        pass

    def list_robots(self, nextToken: str=None, maxResults: int=None, filters: List[Filter]=None) -> ListRobotsResponse:
        pass

    def list_simulation_applications(self, versionQualifier: str=None, nextToken: str=None, maxResults: int=None, filters: List[Filter]=None) -> ListSimulationApplicationsResponse:
        pass

    def list_simulation_jobs(self, nextToken: str=None, maxResults: int=None, filters: List[Filter]=None) -> ListSimulationJobsResponse:
        pass

    def register_robot(self, robot: str, fleet: str) -> RegisterRobotResponse:
        pass

    def restart_simulation_job(self, job: str) -> RestartSimulationJobResponse:
        pass

    def sync_deployment_job(self, fleet: str, clientRequestToken: str) -> SyncDeploymentJobResponse:
        pass

    def update_robot_application(self, robotSoftwareSuite: RobotSoftwareSuite, sources: List[SourceConfig], application: str, currentRevisionId: str=None) -> UpdateRobotApplicationResponse:
        pass

    def update_simulation_application(self, renderingEngine: RenderingEngine, robotSoftwareSuite: RobotSoftwareSuite, simulationSoftwareSuite: SimulationSoftwareSuite, sources: List[SourceConfig], application: str, currentRevisionId: str=None) -> UpdateSimulationApplicationResponse:
        pass


class Route53(BaseClient):
    class AssociateVPCWithHostedZoneRequest(Mapping):
        pass

    class AssociateVPCWithHostedZoneResponse(Mapping):
        pass

    class VPC(Mapping):
        pass

    class ChangeResourceRecordSetsRequest(Mapping):
        pass

    class ChangeResourceRecordSetsResponse(Mapping):
        pass

    class ChangeBatch(Mapping):
        pass

    class ChangeTagsForResourceRequest(Mapping):
        pass

    class ChangeTagsForResourceResponse(Mapping):
        pass

    class Tag(Mapping):
        pass

    class TagKey(object):
        pass

    class CreateHealthCheckRequest(Mapping):
        pass

    class CreateHealthCheckResponse(Mapping):
        pass

    class HealthCheckConfig(Mapping):
        pass

    class CreateHostedZoneRequest(Mapping):
        pass

    class CreateHostedZoneResponse(Mapping):
        pass

    class HostedZoneConfig(Mapping):
        pass

    class CreateQueryLoggingConfigRequest(Mapping):
        pass

    class CreateQueryLoggingConfigResponse(Mapping):
        pass

    class CreateReusableDelegationSetRequest(Mapping):
        pass

    class CreateReusableDelegationSetResponse(Mapping):
        pass

    class CreateTrafficPolicyRequest(Mapping):
        pass

    class CreateTrafficPolicyResponse(Mapping):
        pass

    class CreateTrafficPolicyInstanceRequest(Mapping):
        pass

    class CreateTrafficPolicyInstanceResponse(Mapping):
        pass

    class TTL(object):
        pass

    class CreateTrafficPolicyVersionRequest(Mapping):
        pass

    class CreateTrafficPolicyVersionResponse(Mapping):
        pass

    class CreateVPCAssociationAuthorizationRequest(Mapping):
        pass

    class CreateVPCAssociationAuthorizationResponse(Mapping):
        pass

    class DeleteHealthCheckRequest(Mapping):
        pass

    class DeleteHealthCheckResponse(Mapping):
        pass

    class DeleteHostedZoneRequest(Mapping):
        pass

    class DeleteHostedZoneResponse(Mapping):
        pass

    class DeleteQueryLoggingConfigRequest(Mapping):
        pass

    class DeleteQueryLoggingConfigResponse(Mapping):
        pass

    class DeleteReusableDelegationSetRequest(Mapping):
        pass

    class DeleteReusableDelegationSetResponse(Mapping):
        pass

    class DeleteTrafficPolicyRequest(Mapping):
        pass

    class DeleteTrafficPolicyResponse(Mapping):
        pass

    class DeleteTrafficPolicyInstanceRequest(Mapping):
        pass

    class DeleteTrafficPolicyInstanceResponse(Mapping):
        pass

    class DeleteVPCAssociationAuthorizationRequest(Mapping):
        pass

    class DeleteVPCAssociationAuthorizationResponse(Mapping):
        pass

    class DisassociateVPCFromHostedZoneRequest(Mapping):
        pass

    class DisassociateVPCFromHostedZoneResponse(Mapping):
        pass

    class GetAccountLimitRequest(Mapping):
        pass

    class GetAccountLimitResponse(Mapping):
        pass

    class GetChangeRequest(Mapping):
        pass

    class GetChangeResponse(Mapping):
        pass

    class GetCheckerIpRangesRequest(Mapping):
        pass

    class GetCheckerIpRangesResponse(Mapping):
        pass

    class GetGeoLocationRequest(Mapping):
        pass

    class GetGeoLocationResponse(Mapping):
        pass

    class GetHealthCheckRequest(Mapping):
        pass

    class GetHealthCheckResponse(Mapping):
        pass

    class GetHealthCheckCountRequest(Mapping):
        pass

    class GetHealthCheckCountResponse(Mapping):
        pass

    class GetHealthCheckLastFailureReasonRequest(Mapping):
        pass

    class GetHealthCheckLastFailureReasonResponse(Mapping):
        pass

    class GetHealthCheckStatusRequest(Mapping):
        pass

    class GetHealthCheckStatusResponse(Mapping):
        pass

    class GetHostedZoneRequest(Mapping):
        pass

    class GetHostedZoneResponse(Mapping):
        pass

    class GetHostedZoneCountRequest(Mapping):
        pass

    class GetHostedZoneCountResponse(Mapping):
        pass

    class GetHostedZoneLimitRequest(Mapping):
        pass

    class GetHostedZoneLimitResponse(Mapping):
        pass

    class GetQueryLoggingConfigRequest(Mapping):
        pass

    class GetQueryLoggingConfigResponse(Mapping):
        pass

    class GetReusableDelegationSetRequest(Mapping):
        pass

    class GetReusableDelegationSetResponse(Mapping):
        pass

    class GetReusableDelegationSetLimitRequest(Mapping):
        pass

    class GetReusableDelegationSetLimitResponse(Mapping):
        pass

    class GetTrafficPolicyRequest(Mapping):
        pass

    class GetTrafficPolicyResponse(Mapping):
        pass

    class GetTrafficPolicyInstanceRequest(Mapping):
        pass

    class GetTrafficPolicyInstanceResponse(Mapping):
        pass

    class GetTrafficPolicyInstanceCountRequest(Mapping):
        pass

    class GetTrafficPolicyInstanceCountResponse(Mapping):
        pass

    class ListGeoLocationsRequest(Mapping):
        pass

    class ListGeoLocationsResponse(Mapping):
        pass

    class ListHealthChecksRequest(Mapping):
        pass

    class ListHealthChecksResponse(Mapping):
        pass

    class ListHostedZonesRequest(Mapping):
        pass

    class ListHostedZonesResponse(Mapping):
        pass

    class ListHostedZonesByNameRequest(Mapping):
        pass

    class ListHostedZonesByNameResponse(Mapping):
        pass

    class ListQueryLoggingConfigsRequest(Mapping):
        pass

    class ListQueryLoggingConfigsResponse(Mapping):
        pass

    class ListResourceRecordSetsRequest(Mapping):
        pass

    class ListResourceRecordSetsResponse(Mapping):
        pass

    class ListReusableDelegationSetsRequest(Mapping):
        pass

    class ListReusableDelegationSetsResponse(Mapping):
        pass

    class ListTagsForResourceRequest(Mapping):
        pass

    class ListTagsForResourceResponse(Mapping):
        pass

    class ListTagsForResourcesRequest(Mapping):
        pass

    class ListTagsForResourcesResponse(Mapping):
        pass

    class TagResourceId(object):
        pass

    class ListTrafficPoliciesRequest(Mapping):
        pass

    class ListTrafficPoliciesResponse(Mapping):
        pass

    class ListTrafficPolicyInstancesRequest(Mapping):
        pass

    class ListTrafficPolicyInstancesResponse(Mapping):
        pass

    class ListTrafficPolicyInstancesByHostedZoneRequest(Mapping):
        pass

    class ListTrafficPolicyInstancesByHostedZoneResponse(Mapping):
        pass

    class ListTrafficPolicyInstancesByPolicyRequest(Mapping):
        pass

    class ListTrafficPolicyInstancesByPolicyResponse(Mapping):
        pass

    class ListTrafficPolicyVersionsRequest(Mapping):
        pass

    class ListTrafficPolicyVersionsResponse(Mapping):
        pass

    class ListVPCAssociationAuthorizationsRequest(Mapping):
        pass

    class ListVPCAssociationAuthorizationsResponse(Mapping):
        pass

    class TestDNSAnswerRequest(Mapping):
        pass

    class TestDNSAnswerResponse(Mapping):
        pass

    class UpdateHealthCheckRequest(Mapping):
        pass

    class UpdateHealthCheckResponse(Mapping):
        pass

    class HealthCheckVersion(object):
        pass

    class Inverted(object):
        pass

    class Disabled(object):
        pass

    class HealthCheckId(object):
        pass

    class EnableSNI(object):
        pass

    class HealthCheckRegion(object):
        pass

    class AlarmIdentifier(Mapping):
        pass

    class ResettableElementName(object):
        pass

    class UpdateHostedZoneCommentRequest(Mapping):
        pass

    class UpdateHostedZoneCommentResponse(Mapping):
        pass

    class UpdateTrafficPolicyCommentRequest(Mapping):
        pass

    class UpdateTrafficPolicyCommentResponse(Mapping):
        pass

    class UpdateTrafficPolicyInstanceRequest(Mapping):
        pass

    class UpdateTrafficPolicyInstanceResponse(Mapping):
        pass

    def associate_vpc_with_hosted_zone(self, VPC: VPC, HostedZoneId: str, Comment: str=None) -> AssociateVPCWithHostedZoneResponse:
        pass

    def change_resource_record_sets(self, ChangeBatch: ChangeBatch, HostedZoneId: str) -> ChangeResourceRecordSetsResponse:
        pass

    def change_tags_for_resource(self, ResourceId: str, ResourceType: str, AddTags: List[Tag]=None, RemoveTagKeys: List[TagKey]=None) -> ChangeTagsForResourceResponse:
        pass

    def create_health_check(self, HealthCheckConfig: HealthCheckConfig, CallerReference: str) -> CreateHealthCheckResponse:
        pass

    def create_hosted_zone(self, CallerReference: str, Name: str, VPC: VPC=None, HostedZoneConfig: HostedZoneConfig=None, DelegationSetId: str=None) -> CreateHostedZoneResponse:
        pass

    def create_query_logging_config(self, CloudWatchLogsLogGroupArn: str, HostedZoneId: str) -> CreateQueryLoggingConfigResponse:
        pass

    def create_reusable_delegation_set(self, CallerReference: str, HostedZoneId: str=None) -> CreateReusableDelegationSetResponse:
        pass

    def create_traffic_policy(self, Document: str, Name: str, Comment: str=None) -> CreateTrafficPolicyResponse:
        pass

    def create_traffic_policy_instance(self, TrafficPolicyVersion: int, TrafficPolicyId: str, TTL: TTL, Name: str, HostedZoneId: str) -> CreateTrafficPolicyInstanceResponse:
        pass

    def create_traffic_policy_version(self, Document: str, Id: str, Comment: str=None) -> CreateTrafficPolicyVersionResponse:
        pass

    def create_vpc_association_authorization(self, VPC: VPC, HostedZoneId: str) -> CreateVPCAssociationAuthorizationResponse:
        pass

    def delete_health_check(self, HealthCheckId: str) -> DeleteHealthCheckResponse:
        pass

    def delete_hosted_zone(self, Id: str) -> DeleteHostedZoneResponse:
        pass

    def delete_query_logging_config(self, Id: str) -> DeleteQueryLoggingConfigResponse:
        pass

    def delete_reusable_delegation_set(self, Id: str) -> DeleteReusableDelegationSetResponse:
        pass

    def delete_traffic_policy(self, Version: int, Id: str) -> DeleteTrafficPolicyResponse:
        pass

    def delete_traffic_policy_instance(self, Id: str) -> DeleteTrafficPolicyInstanceResponse:
        pass

    def delete_vpc_association_authorization(self, VPC: VPC, HostedZoneId: str) -> DeleteVPCAssociationAuthorizationResponse:
        pass

    def disassociate_vpc_from_hosted_zone(self, VPC: VPC, HostedZoneId: str, Comment: str=None) -> DisassociateVPCFromHostedZoneResponse:
        pass

    def get_account_limit(self, Type: str) -> GetAccountLimitResponse:
        pass

    def get_change(self, Id: str) -> GetChangeResponse:
        pass

    def get_checker_ip_ranges(self) -> GetCheckerIpRangesResponse:
        pass

    def get_geo_location(self, ContinentCode: str=None, CountryCode: str=None, SubdivisionCode: str=None) -> GetGeoLocationResponse:
        pass

    def get_health_check(self, HealthCheckId: str) -> GetHealthCheckResponse:
        pass

    def get_health_check_count(self) -> GetHealthCheckCountResponse:
        pass

    def get_health_check_last_failure_reason(self, HealthCheckId: str) -> GetHealthCheckLastFailureReasonResponse:
        pass

    def get_health_check_status(self, HealthCheckId: str) -> GetHealthCheckStatusResponse:
        pass

    def get_hosted_zone(self, Id: str) -> GetHostedZoneResponse:
        pass

    def get_hosted_zone_count(self) -> GetHostedZoneCountResponse:
        pass

    def get_hosted_zone_limit(self, HostedZoneId: str, Type: str) -> GetHostedZoneLimitResponse:
        pass

    def get_query_logging_config(self, Id: str) -> GetQueryLoggingConfigResponse:
        pass

    def get_reusable_delegation_set(self, Id: str) -> GetReusableDelegationSetResponse:
        pass

    def get_reusable_delegation_set_limit(self, DelegationSetId: str, Type: str) -> GetReusableDelegationSetLimitResponse:
        pass

    def get_traffic_policy(self, Version: int, Id: str) -> GetTrafficPolicyResponse:
        pass

    def get_traffic_policy_instance(self, Id: str) -> GetTrafficPolicyInstanceResponse:
        pass

    def get_traffic_policy_instance_count(self) -> GetTrafficPolicyInstanceCountResponse:
        pass

    def list_geo_locations(self, StartContinentCode: str=None, StartCountryCode: str=None, StartSubdivisionCode: str=None, MaxItems: str=None) -> ListGeoLocationsResponse:
        pass

    def list_health_checks(self, Marker: str=None, MaxItems: str=None) -> ListHealthChecksResponse:
        pass

    def list_hosted_zones(self, Marker: str=None, MaxItems: str=None, DelegationSetId: str=None) -> ListHostedZonesResponse:
        pass

    def list_hosted_zones_by_name(self, DNSName: str=None, HostedZoneId: str=None, MaxItems: str=None) -> ListHostedZonesByNameResponse:
        pass

    def list_query_logging_configs(self, HostedZoneId: str=None, NextToken: str=None, MaxResults: str=None) -> ListQueryLoggingConfigsResponse:
        pass

    def list_resource_record_sets(self, HostedZoneId: str, StartRecordName: str=None, StartRecordType: str=None, StartRecordIdentifier: str=None, MaxItems: str=None) -> ListResourceRecordSetsResponse:
        pass

    def list_reusable_delegation_sets(self, Marker: str=None, MaxItems: str=None) -> ListReusableDelegationSetsResponse:
        pass

    def list_tags_for_resource(self, ResourceId: str, ResourceType: str) -> ListTagsForResourceResponse:
        pass

    def list_tags_for_resources(self, ResourceIds: List[TagResourceId], ResourceType: str) -> ListTagsForResourcesResponse:
        pass

    def list_traffic_policies(self, TrafficPolicyIdMarker: str=None, MaxItems: str=None) -> ListTrafficPoliciesResponse:
        pass

    def list_traffic_policy_instances(self, HostedZoneIdMarker: str=None, TrafficPolicyInstanceNameMarker: str=None, TrafficPolicyInstanceTypeMarker: str=None, MaxItems: str=None) -> ListTrafficPolicyInstancesResponse:
        pass

    def list_traffic_policy_instances_by_hosted_zone(self, HostedZoneId: str, TrafficPolicyInstanceNameMarker: str=None, TrafficPolicyInstanceTypeMarker: str=None, MaxItems: str=None) -> ListTrafficPolicyInstancesByHostedZoneResponse:
        pass

    def list_traffic_policy_instances_by_policy(self, TrafficPolicyVersion: int, TrafficPolicyId: str, HostedZoneIdMarker: str=None, TrafficPolicyInstanceNameMarker: str=None, TrafficPolicyInstanceTypeMarker: str=None, MaxItems: str=None) -> ListTrafficPolicyInstancesByPolicyResponse:
        pass

    def list_traffic_policy_versions(self, Id: str, TrafficPolicyVersionMarker: str=None, MaxItems: str=None) -> ListTrafficPolicyVersionsResponse:
        pass

    def list_vpc_association_authorizations(self, HostedZoneId: str, NextToken: str=None, MaxResults: str=None) -> ListVPCAssociationAuthorizationsResponse:
        pass

    def test_dns_answer(self, RecordType: str, RecordName: str, HostedZoneId: str, ResolverIP: str=None, EDNS0ClientSubnetIP: str=None, EDNS0ClientSubnetMask: str=None) -> TestDNSAnswerResponse:
        pass

    def update_health_check(self, HealthCheckId: str, HealthCheckVersion: HealthCheckVersion=None, IPAddress: str=None, Port: int=None, ResourcePath: str=None, FullyQualifiedDomainName: str=None, SearchString: str=None, FailureThreshold: int=None, Inverted: Inverted=None, Disabled: Disabled=None, HealthThreshold: int=None, ChildHealthChecks: List[HealthCheckId]=None, EnableSNI: EnableSNI=None, Regions: List[HealthCheckRegion]=None, AlarmIdentifier: AlarmIdentifier=None, InsufficientDataHealthStatus: str=None, ResetElements: List[ResettableElementName]=None) -> UpdateHealthCheckResponse:
        pass

    def update_hosted_zone_comment(self, Id: str, Comment: str=None) -> UpdateHostedZoneCommentResponse:
        pass

    def update_traffic_policy_comment(self, Comment: str, Version: int, Id: str) -> UpdateTrafficPolicyCommentResponse:
        pass

    def update_traffic_policy_instance(self, TrafficPolicyVersion: int, TrafficPolicyId: str, TTL: TTL, Id: str) -> UpdateTrafficPolicyInstanceResponse:
        pass


class Route53Domains(BaseClient):
    class CheckDomainAvailabilityRequest(Mapping):
        pass

    class CheckDomainAvailabilityResponse(Mapping):
        pass

    class CheckDomainTransferabilityRequest(Mapping):
        pass

    class CheckDomainTransferabilityResponse(Mapping):
        pass

    class DeleteTagsForDomainRequest(Mapping):
        pass

    class DeleteTagsForDomainResponse(Mapping):
        pass

    class TagKey(object):
        pass

    class DisableDomainAutoRenewRequest(Mapping):
        pass

    class DisableDomainAutoRenewResponse(Mapping):
        pass

    class DisableDomainTransferLockRequest(Mapping):
        pass

    class DisableDomainTransferLockResponse(Mapping):
        pass

    class EnableDomainAutoRenewRequest(Mapping):
        pass

    class EnableDomainAutoRenewResponse(Mapping):
        pass

    class EnableDomainTransferLockRequest(Mapping):
        pass

    class EnableDomainTransferLockResponse(Mapping):
        pass

    class GetContactReachabilityStatusRequest(Mapping):
        pass

    class GetContactReachabilityStatusResponse(Mapping):
        pass

    class GetDomainDetailRequest(Mapping):
        pass

    class GetDomainDetailResponse(Mapping):
        pass

    class GetDomainSuggestionsRequest(Mapping):
        pass

    class GetDomainSuggestionsResponse(Mapping):
        pass

    class Boolean(object):
        pass

    class GetOperationDetailRequest(Mapping):
        pass

    class GetOperationDetailResponse(Mapping):
        pass

    class ListDomainsRequest(Mapping):
        pass

    class ListDomainsResponse(Mapping):
        pass

    class ListOperationsRequest(Mapping):
        pass

    class ListOperationsResponse(Mapping):
        pass

    class Timestamp(object):
        pass

    class ListTagsForDomainRequest(Mapping):
        pass

    class ListTagsForDomainResponse(Mapping):
        pass

    class RegisterDomainRequest(Mapping):
        pass

    class RegisterDomainResponse(Mapping):
        pass

    class ContactDetail(Mapping):
        pass

    class RenewDomainRequest(Mapping):
        pass

    class RenewDomainResponse(Mapping):
        pass

    class ResendContactReachabilityEmailRequest(Mapping):
        pass

    class ResendContactReachabilityEmailResponse(Mapping):
        pass

    class RetrieveDomainAuthCodeRequest(Mapping):
        pass

    class RetrieveDomainAuthCodeResponse(Mapping):
        pass

    class TransferDomainRequest(Mapping):
        pass

    class TransferDomainResponse(Mapping):
        pass

    class Nameserver(Mapping):
        pass

    class UpdateDomainContactRequest(Mapping):
        pass

    class UpdateDomainContactResponse(Mapping):
        pass

    class UpdateDomainContactPrivacyRequest(Mapping):
        pass

    class UpdateDomainContactPrivacyResponse(Mapping):
        pass

    class UpdateDomainNameserversRequest(Mapping):
        pass

    class UpdateDomainNameserversResponse(Mapping):
        pass

    class UpdateTagsForDomainRequest(Mapping):
        pass

    class UpdateTagsForDomainResponse(Mapping):
        pass

    class Tag(Mapping):
        pass

    class ViewBillingRequest(Mapping):
        pass

    class ViewBillingResponse(Mapping):
        pass

    def check_domain_availability(self, DomainName: str, IdnLangCode: str=None) -> CheckDomainAvailabilityResponse:
        pass

    def check_domain_transferability(self, DomainName: str, AuthCode: str=None) -> CheckDomainTransferabilityResponse:
        pass

    def delete_tags_for_domain(self, TagsToDelete: List[TagKey], DomainName: str) -> DeleteTagsForDomainResponse:
        pass

    def disable_domain_auto_renew(self, DomainName: str) -> DisableDomainAutoRenewResponse:
        pass

    def disable_domain_transfer_lock(self, DomainName: str) -> DisableDomainTransferLockResponse:
        pass

    def enable_domain_auto_renew(self, DomainName: str) -> EnableDomainAutoRenewResponse:
        pass

    def enable_domain_transfer_lock(self, DomainName: str) -> EnableDomainTransferLockResponse:
        pass

    def get_contact_reachability_status(self, domainName: str=None) -> GetContactReachabilityStatusResponse:
        pass

    def get_domain_detail(self, DomainName: str) -> GetDomainDetailResponse:
        pass

    def get_domain_suggestions(self, OnlyAvailable: Boolean, SuggestionCount: int, DomainName: str) -> GetDomainSuggestionsResponse:
        pass

    def get_operation_detail(self, OperationId: str) -> GetOperationDetailResponse:
        pass

    def list_domains(self, Marker: str=None, MaxItems: int=None) -> ListDomainsResponse:
        pass

    def list_operations(self, SubmittedSince: Timestamp=None, Marker: str=None, MaxItems: int=None) -> ListOperationsResponse:
        pass

    def list_tags_for_domain(self, DomainName: str) -> ListTagsForDomainResponse:
        pass

    def register_domain(self, TechContact: ContactDetail, RegistrantContact: ContactDetail, AdminContact: ContactDetail, DurationInYears: int, DomainName: str, IdnLangCode: str=None, AutoRenew: Boolean=None, PrivacyProtectAdminContact: Boolean=None, PrivacyProtectRegistrantContact: Boolean=None, PrivacyProtectTechContact: Boolean=None) -> RegisterDomainResponse:
        pass

    def renew_domain(self, CurrentExpiryYear: int, DomainName: str, DurationInYears: int=None) -> RenewDomainResponse:
        pass

    def resend_contact_reachability_email(self, domainName: str=None) -> ResendContactReachabilityEmailResponse:
        pass

    def retrieve_domain_auth_code(self, DomainName: str) -> RetrieveDomainAuthCodeResponse:
        pass

    def transfer_domain(self, TechContact: ContactDetail, RegistrantContact: ContactDetail, AdminContact: ContactDetail, DurationInYears: int, DomainName: str, IdnLangCode: str=None, Nameservers: List[Nameserver]=None, AuthCode: str=None, AutoRenew: Boolean=None, PrivacyProtectAdminContact: Boolean=None, PrivacyProtectRegistrantContact: Boolean=None, PrivacyProtectTechContact: Boolean=None) -> TransferDomainResponse:
        pass

    def update_domain_contact(self, DomainName: str, AdminContact: ContactDetail=None, RegistrantContact: ContactDetail=None, TechContact: ContactDetail=None) -> UpdateDomainContactResponse:
        pass

    def update_domain_contact_privacy(self, DomainName: str, AdminPrivacy: Boolean=None, RegistrantPrivacy: Boolean=None, TechPrivacy: Boolean=None) -> UpdateDomainContactPrivacyResponse:
        pass

    def update_domain_nameservers(self, Nameservers: List[Nameserver], DomainName: str, FIAuthKey: str=None) -> UpdateDomainNameserversResponse:
        pass

    def update_tags_for_domain(self, DomainName: str, TagsToUpdate: List[Tag]=None) -> UpdateTagsForDomainResponse:
        pass

    def view_billing(self, Start: Timestamp=None, End: Timestamp=None, Marker: str=None, MaxItems: int=None) -> ViewBillingResponse:
        pass


class Route53Resolver(BaseClient):
    class AssociateResolverEndpointIpAddressRequest(Mapping):
        pass

    class AssociateResolverEndpointIpAddressResponse(Mapping):
        pass

    class IpAddressUpdate(Mapping):
        pass

    class AssociateResolverRuleRequest(Mapping):
        pass

    class AssociateResolverRuleResponse(Mapping):
        pass

    class CreateResolverEndpointRequest(Mapping):
        pass

    class CreateResolverEndpointResponse(Mapping):
        pass

    class ResourceId(object):
        pass

    class IpAddressRequest(Mapping):
        pass

    class Tag(Mapping):
        pass

    class CreateResolverRuleRequest(Mapping):
        pass

    class CreateResolverRuleResponse(Mapping):
        pass

    class TargetAddress(Mapping):
        pass

    class DeleteResolverEndpointRequest(Mapping):
        pass

    class DeleteResolverEndpointResponse(Mapping):
        pass

    class DeleteResolverRuleRequest(Mapping):
        pass

    class DeleteResolverRuleResponse(Mapping):
        pass

    class DisassociateResolverEndpointIpAddressRequest(Mapping):
        pass

    class DisassociateResolverEndpointIpAddressResponse(Mapping):
        pass

    class DisassociateResolverRuleRequest(Mapping):
        pass

    class DisassociateResolverRuleResponse(Mapping):
        pass

    class GetResolverEndpointRequest(Mapping):
        pass

    class GetResolverEndpointResponse(Mapping):
        pass

    class GetResolverRuleRequest(Mapping):
        pass

    class GetResolverRuleResponse(Mapping):
        pass

    class GetResolverRuleAssociationRequest(Mapping):
        pass

    class GetResolverRuleAssociationResponse(Mapping):
        pass

    class GetResolverRulePolicyRequest(Mapping):
        pass

    class GetResolverRulePolicyResponse(Mapping):
        pass

    class ListResolverEndpointIpAddressesRequest(Mapping):
        pass

    class ListResolverEndpointIpAddressesResponse(Mapping):
        pass

    class ListResolverEndpointsRequest(Mapping):
        pass

    class ListResolverEndpointsResponse(Mapping):
        pass

    class Filter(Mapping):
        pass

    class ListResolverRuleAssociationsRequest(Mapping):
        pass

    class ListResolverRuleAssociationsResponse(Mapping):
        pass

    class ListResolverRulesRequest(Mapping):
        pass

    class ListResolverRulesResponse(Mapping):
        pass

    class ListTagsForResourceRequest(Mapping):
        pass

    class ListTagsForResourceResponse(Mapping):
        pass

    class PutResolverRulePolicyRequest(Mapping):
        pass

    class PutResolverRulePolicyResponse(Mapping):
        pass

    class TagResourceRequest(Mapping):
        pass

    class TagResourceResponse(Mapping):
        pass

    class UntagResourceRequest(Mapping):
        pass

    class UntagResourceResponse(Mapping):
        pass

    class TagKey(object):
        pass

    class UpdateResolverEndpointRequest(Mapping):
        pass

    class UpdateResolverEndpointResponse(Mapping):
        pass

    class UpdateResolverRuleRequest(Mapping):
        pass

    class UpdateResolverRuleResponse(Mapping):
        pass

    class ResolverRuleConfig(Mapping):
        pass

    def associate_resolver_endpoint_ip_address(self, IpAddress: IpAddressUpdate, ResolverEndpointId: str) -> AssociateResolverEndpointIpAddressResponse:
        pass

    def associate_resolver_rule(self, VPCId: str, ResolverRuleId: str, Name: str=None) -> AssociateResolverRuleResponse:
        pass

    def create_resolver_endpoint(self, IpAddresses: List[IpAddressRequest], Direction: str, SecurityGroupIds: List[ResourceId], CreatorRequestId: str, Name: str=None, Tags: List[Tag]=None) -> CreateResolverEndpointResponse:
        pass

    def create_resolver_rule(self, DomainName: str, RuleType: str, CreatorRequestId: str, Name: str=None, TargetIps: List[TargetAddress]=None, ResolverEndpointId: str=None, Tags: List[Tag]=None) -> CreateResolverRuleResponse:
        pass

    def delete_resolver_endpoint(self, ResolverEndpointId: str) -> DeleteResolverEndpointResponse:
        pass

    def delete_resolver_rule(self, ResolverRuleId: str) -> DeleteResolverRuleResponse:
        pass

    def disassociate_resolver_endpoint_ip_address(self, IpAddress: IpAddressUpdate, ResolverEndpointId: str) -> DisassociateResolverEndpointIpAddressResponse:
        pass

    def disassociate_resolver_rule(self, ResolverRuleId: str, VPCId: str) -> DisassociateResolverRuleResponse:
        pass

    def get_resolver_endpoint(self, ResolverEndpointId: str) -> GetResolverEndpointResponse:
        pass

    def get_resolver_rule(self, ResolverRuleId: str) -> GetResolverRuleResponse:
        pass

    def get_resolver_rule_association(self, ResolverRuleAssociationId: str) -> GetResolverRuleAssociationResponse:
        pass

    def get_resolver_rule_policy(self, Arn: str) -> GetResolverRulePolicyResponse:
        pass

    def list_resolver_endpoint_ip_addresses(self, ResolverEndpointId: str, MaxResults: int=None, NextToken: str=None) -> ListResolverEndpointIpAddressesResponse:
        pass

    def list_resolver_endpoints(self, MaxResults: int=None, NextToken: str=None, Filters: List[Filter]=None) -> ListResolverEndpointsResponse:
        pass

    def list_resolver_rule_associations(self, MaxResults: int=None, NextToken: str=None, Filters: List[Filter]=None) -> ListResolverRuleAssociationsResponse:
        pass

    def list_resolver_rules(self, MaxResults: int=None, NextToken: str=None, Filters: List[Filter]=None) -> ListResolverRulesResponse:
        pass

    def list_tags_for_resource(self, ResourceArn: str, MaxResults: int=None, NextToken: str=None) -> ListTagsForResourceResponse:
        pass

    def put_resolver_rule_policy(self, ResolverRulePolicy: str, Arn: str) -> PutResolverRulePolicyResponse:
        pass

    def tag_resource(self, Tags: List[Tag], ResourceArn: str) -> TagResourceResponse:
        pass

    def untag_resource(self, TagKeys: List[TagKey], ResourceArn: str) -> UntagResourceResponse:
        pass

    def update_resolver_endpoint(self, ResolverEndpointId: str, Name: str=None) -> UpdateResolverEndpointResponse:
        pass

    def update_resolver_rule(self, Config: ResolverRuleConfig, ResolverRuleId: str) -> UpdateResolverRuleResponse:
        pass


class S3(BaseClient):
    class AbortMultipartUploadRequest(Mapping):
        pass

    class AbortMultipartUploadOutput(Mapping):
        pass

    class CompleteMultipartUploadRequest(Mapping):
        pass

    class CompleteMultipartUploadOutput(Mapping):
        pass

    class CompletedMultipartUpload(Mapping):
        pass

    class CopyObjectRequest(Mapping):
        pass

    class CopyObjectOutput(Mapping):
        pass

    class CopySourceIfModifiedSince(object):
        pass

    class CopySourceIfUnmodifiedSince(object):
        pass

    class Expires(object):
        pass

    class Metadata(object):
        pass

    class ObjectLockRetainUntilDate(object):
        pass

    class CreateBucketRequest(Mapping):
        pass

    class CreateBucketOutput(Mapping):
        pass

    class CreateBucketConfiguration(Mapping):
        pass

    class ObjectLockEnabledForBucket(object):
        pass

    class CreateMultipartUploadRequest(Mapping):
        pass

    class CreateMultipartUploadOutput(Mapping):
        pass

    class DeleteBucketRequest(Mapping):
        pass

    class DeleteBucketAnalyticsConfigurationRequest(Mapping):
        pass

    class DeleteBucketCorsRequest(Mapping):
        pass

    class DeleteBucketEncryptionRequest(Mapping):
        pass

    class DeleteBucketInventoryConfigurationRequest(Mapping):
        pass

    class DeleteBucketLifecycleRequest(Mapping):
        pass

    class DeleteBucketMetricsConfigurationRequest(Mapping):
        pass

    class DeleteBucketPolicyRequest(Mapping):
        pass

    class DeleteBucketReplicationRequest(Mapping):
        pass

    class DeleteBucketTaggingRequest(Mapping):
        pass

    class DeleteBucketWebsiteRequest(Mapping):
        pass

    class DeleteObjectRequest(Mapping):
        pass

    class DeleteObjectOutput(Mapping):
        pass

    class BypassGovernanceRetention(object):
        pass

    class DeleteObjectTaggingRequest(Mapping):
        pass

    class DeleteObjectTaggingOutput(Mapping):
        pass

    class DeleteObjectsRequest(Mapping):
        pass

    class DeleteObjectsOutput(Mapping):
        pass

    class Delete(Mapping):
        pass

    class DeletePublicAccessBlockRequest(Mapping):
        pass

    class GetBucketAccelerateConfigurationRequest(Mapping):
        pass

    class GetBucketAccelerateConfigurationOutput(Mapping):
        pass

    class GetBucketAclRequest(Mapping):
        pass

    class GetBucketAclOutput(Mapping):
        pass

    class GetBucketAnalyticsConfigurationRequest(Mapping):
        pass

    class GetBucketAnalyticsConfigurationOutput(Mapping):
        pass

    class GetBucketCorsRequest(Mapping):
        pass

    class GetBucketCorsOutput(Mapping):
        pass

    class GetBucketEncryptionRequest(Mapping):
        pass

    class GetBucketEncryptionOutput(Mapping):
        pass

    class GetBucketInventoryConfigurationRequest(Mapping):
        pass

    class GetBucketInventoryConfigurationOutput(Mapping):
        pass

    class GetBucketLifecycleRequest(Mapping):
        pass

    class GetBucketLifecycleOutput(Mapping):
        pass

    class GetBucketLifecycleConfigurationRequest(Mapping):
        pass

    class GetBucketLifecycleConfigurationOutput(Mapping):
        pass

    class GetBucketLocationRequest(Mapping):
        pass

    class GetBucketLocationOutput(Mapping):
        pass

    class GetBucketLoggingRequest(Mapping):
        pass

    class GetBucketLoggingOutput(Mapping):
        pass

    class GetBucketMetricsConfigurationRequest(Mapping):
        pass

    class GetBucketMetricsConfigurationOutput(Mapping):
        pass

    class GetBucketNotificationConfigurationRequest(Mapping):
        pass

    class NotificationConfigurationDeprecated(Mapping):
        pass

    class NotificationConfiguration(Mapping):
        pass

    class GetBucketPolicyRequest(Mapping):
        pass

    class GetBucketPolicyOutput(Mapping):
        pass

    class GetBucketPolicyStatusRequest(Mapping):
        pass

    class GetBucketPolicyStatusOutput(Mapping):
        pass

    class GetBucketReplicationRequest(Mapping):
        pass

    class GetBucketReplicationOutput(Mapping):
        pass

    class GetBucketRequestPaymentRequest(Mapping):
        pass

    class GetBucketRequestPaymentOutput(Mapping):
        pass

    class GetBucketTaggingRequest(Mapping):
        pass

    class GetBucketTaggingOutput(Mapping):
        pass

    class GetBucketVersioningRequest(Mapping):
        pass

    class GetBucketVersioningOutput(Mapping):
        pass

    class GetBucketWebsiteRequest(Mapping):
        pass

    class GetBucketWebsiteOutput(Mapping):
        pass

    class GetObjectRequest(Mapping):
        pass

    class GetObjectOutput(Mapping):
        pass

    class IfModifiedSince(object):
        pass

    class IfUnmodifiedSince(object):
        pass

    class ResponseExpires(object):
        pass

    class GetObjectAclRequest(Mapping):
        pass

    class GetObjectAclOutput(Mapping):
        pass

    class GetObjectLegalHoldRequest(Mapping):
        pass

    class GetObjectLegalHoldOutput(Mapping):
        pass

    class GetObjectLockConfigurationRequest(Mapping):
        pass

    class GetObjectLockConfigurationOutput(Mapping):
        pass

    class GetObjectRetentionRequest(Mapping):
        pass

    class GetObjectRetentionOutput(Mapping):
        pass

    class GetObjectTaggingRequest(Mapping):
        pass

    class GetObjectTaggingOutput(Mapping):
        pass

    class GetObjectTorrentRequest(Mapping):
        pass

    class GetObjectTorrentOutput(Mapping):
        pass

    class GetPublicAccessBlockRequest(Mapping):
        pass

    class GetPublicAccessBlockOutput(Mapping):
        pass

    class HeadBucketRequest(Mapping):
        pass

    class HeadObjectRequest(Mapping):
        pass

    class HeadObjectOutput(Mapping):
        pass

    class ListBucketAnalyticsConfigurationsRequest(Mapping):
        pass

    class ListBucketAnalyticsConfigurationsOutput(Mapping):
        pass

    class ListBucketInventoryConfigurationsRequest(Mapping):
        pass

    class ListBucketInventoryConfigurationsOutput(Mapping):
        pass

    class ListBucketMetricsConfigurationsRequest(Mapping):
        pass

    class ListBucketMetricsConfigurationsOutput(Mapping):
        pass

    class ListBucketsOutput(Mapping):
        pass

    class ListMultipartUploadsRequest(Mapping):
        pass

    class ListMultipartUploadsOutput(Mapping):
        pass

    class ListObjectVersionsRequest(Mapping):
        pass

    class ListObjectVersionsOutput(Mapping):
        pass

    class ListObjectsRequest(Mapping):
        pass

    class ListObjectsOutput(Mapping):
        pass

    class ListObjectsV2Request(Mapping):
        pass

    class ListObjectsV2Output(Mapping):
        pass

    class FetchOwner(object):
        pass

    class ListPartsRequest(Mapping):
        pass

    class ListPartsOutput(Mapping):
        pass

    class PutBucketAccelerateConfigurationRequest(Mapping):
        pass

    class AccelerateConfiguration(Mapping):
        pass

    class PutBucketAclRequest(Mapping):
        pass

    class AccessControlPolicy(Mapping):
        pass

    class PutBucketAnalyticsConfigurationRequest(Mapping):
        pass

    class AnalyticsConfiguration(Mapping):
        pass

    class PutBucketCorsRequest(Mapping):
        pass

    class CORSConfiguration(Mapping):
        pass

    class PutBucketEncryptionRequest(Mapping):
        pass

    class ServerSideEncryptionConfiguration(Mapping):
        pass

    class PutBucketInventoryConfigurationRequest(Mapping):
        pass

    class InventoryConfiguration(Mapping):
        pass

    class PutBucketLifecycleRequest(Mapping):
        pass

    class LifecycleConfiguration(Mapping):
        pass

    class PutBucketLifecycleConfigurationRequest(Mapping):
        pass

    class BucketLifecycleConfiguration(Mapping):
        pass

    class PutBucketLoggingRequest(Mapping):
        pass

    class BucketLoggingStatus(Mapping):
        pass

    class PutBucketMetricsConfigurationRequest(Mapping):
        pass

    class MetricsConfiguration(Mapping):
        pass

    class PutBucketNotificationRequest(Mapping):
        pass

    class PutBucketNotificationConfigurationRequest(Mapping):
        pass

    class PutBucketPolicyRequest(Mapping):
        pass

    class ConfirmRemoveSelfBucketAccess(object):
        pass

    class PutBucketReplicationRequest(Mapping):
        pass

    class ReplicationConfiguration(Mapping):
        pass

    class PutBucketRequestPaymentRequest(Mapping):
        pass

    class RequestPaymentConfiguration(Mapping):
        pass

    class PutBucketTaggingRequest(Mapping):
        pass

    class Tagging(Mapping):
        pass

    class PutBucketVersioningRequest(Mapping):
        pass

    class VersioningConfiguration(Mapping):
        pass

    class PutBucketWebsiteRequest(Mapping):
        pass

    class WebsiteConfiguration(Mapping):
        pass

    class PutObjectRequest(Mapping):
        pass

    class PutObjectOutput(Mapping):
        pass

    class Body(object):
        pass

    class ContentLength(object):
        pass

    class PutObjectAclRequest(Mapping):
        pass

    class PutObjectAclOutput(Mapping):
        pass

    class PutObjectLegalHoldRequest(Mapping):
        pass

    class PutObjectLegalHoldOutput(Mapping):
        pass

    class ObjectLockLegalHold(Mapping):
        pass

    class PutObjectLockConfigurationRequest(Mapping):
        pass

    class PutObjectLockConfigurationOutput(Mapping):
        pass

    class ObjectLockConfiguration(Mapping):
        pass

    class PutObjectRetentionRequest(Mapping):
        pass

    class PutObjectRetentionOutput(Mapping):
        pass

    class ObjectLockRetention(Mapping):
        pass

    class PutObjectTaggingRequest(Mapping):
        pass

    class PutObjectTaggingOutput(Mapping):
        pass

    class PutPublicAccessBlockRequest(Mapping):
        pass

    class PublicAccessBlockConfiguration(Mapping):
        pass

    class RestoreObjectRequest(Mapping):
        pass

    class RestoreObjectOutput(Mapping):
        pass

    class RestoreRequest(Mapping):
        pass

    class SelectObjectContentRequest(Mapping):
        pass

    class SelectObjectContentOutput(Mapping):
        pass

    class RequestProgress(Mapping):
        pass

    class InputSerialization(Mapping):
        pass

    class OutputSerialization(Mapping):
        pass

    class UploadPartRequest(Mapping):
        pass

    class UploadPartOutput(Mapping):
        pass

    class UploadPartCopyRequest(Mapping):
        pass

    class UploadPartCopyOutput(Mapping):
        pass

    def abort_multipart_upload(self, UploadId: str, Key: str, Bucket: str, RequestPayer: str=None) -> AbortMultipartUploadOutput:
        pass

    def complete_multipart_upload(self, UploadId: str, Key: str, Bucket: str, MultipartUpload: CompletedMultipartUpload=None, RequestPayer: str=None) -> CompleteMultipartUploadOutput:
        pass

    def copy_object(self, Key: str, CopySource: str, Bucket: str, ACL: str=None, CacheControl: str=None, ContentDisposition: str=None, ContentEncoding: str=None, ContentLanguage: str=None, ContentType: str=None, CopySourceIfMatch: str=None, CopySourceIfModifiedSince: CopySourceIfModifiedSince=None, CopySourceIfNoneMatch: str=None, CopySourceIfUnmodifiedSince: CopySourceIfUnmodifiedSince=None, Expires: Expires=None, GrantFullControl: str=None, GrantRead: str=None, GrantReadACP: str=None, GrantWriteACP: str=None, Metadata: Metadata=None, MetadataDirective: str=None, TaggingDirective: str=None, ServerSideEncryption: str=None, StorageClass: str=None, WebsiteRedirectLocation: str=None, SSECustomerAlgorithm: str=None, SSECustomerKey: str=None, SSECustomerKeyMD5: str=None, SSEKMSKeyId: str=None, CopySourceSSECustomerAlgorithm: str=None, CopySourceSSECustomerKey: str=None, CopySourceSSECustomerKeyMD5: str=None, RequestPayer: str=None, Tagging: str=None, ObjectLockMode: str=None, ObjectLockRetainUntilDate: ObjectLockRetainUntilDate=None, ObjectLockLegalHoldStatus: str=None) -> CopyObjectOutput:
        pass

    def create_bucket(self, Bucket: str, ACL: str=None, CreateBucketConfiguration: CreateBucketConfiguration=None, GrantFullControl: str=None, GrantRead: str=None, GrantReadACP: str=None, GrantWrite: str=None, GrantWriteACP: str=None, ObjectLockEnabledForBucket: ObjectLockEnabledForBucket=None) -> CreateBucketOutput:
        pass

    def create_multipart_upload(self, Key: str, Bucket: str, ACL: str=None, CacheControl: str=None, ContentDisposition: str=None, ContentEncoding: str=None, ContentLanguage: str=None, ContentType: str=None, Expires: Expires=None, GrantFullControl: str=None, GrantRead: str=None, GrantReadACP: str=None, GrantWriteACP: str=None, Metadata: Metadata=None, ServerSideEncryption: str=None, StorageClass: str=None, WebsiteRedirectLocation: str=None, SSECustomerAlgorithm: str=None, SSECustomerKey: str=None, SSECustomerKeyMD5: str=None, SSEKMSKeyId: str=None, RequestPayer: str=None, Tagging: str=None, ObjectLockMode: str=None, ObjectLockRetainUntilDate: ObjectLockRetainUntilDate=None, ObjectLockLegalHoldStatus: str=None) -> CreateMultipartUploadOutput:
        pass

    def delete_bucket(self, Bucket: str):
        pass

    def delete_bucket_analytics_configuration(self, Id: str, Bucket: str):
        pass

    def delete_bucket_cors(self, Bucket: str):
        pass

    def delete_bucket_encryption(self, Bucket: str):
        pass

    def delete_bucket_inventory_configuration(self, Id: str, Bucket: str):
        pass

    def delete_bucket_lifecycle(self, Bucket: str):
        pass

    def delete_bucket_metrics_configuration(self, Id: str, Bucket: str):
        pass

    def delete_bucket_policy(self, Bucket: str):
        pass

    def delete_bucket_replication(self, Bucket: str):
        pass

    def delete_bucket_tagging(self, Bucket: str):
        pass

    def delete_bucket_website(self, Bucket: str):
        pass

    def delete_object(self, Key: str, Bucket: str, MFA: str=None, VersionId: str=None, RequestPayer: str=None, BypassGovernanceRetention: BypassGovernanceRetention=None) -> DeleteObjectOutput:
        pass

    def delete_object_tagging(self, Key: str, Bucket: str, VersionId: str=None) -> DeleteObjectTaggingOutput:
        pass

    def delete_objects(self, Delete: Delete, Bucket: str, MFA: str=None, RequestPayer: str=None, BypassGovernanceRetention: BypassGovernanceRetention=None) -> DeleteObjectsOutput:
        pass

    def delete_public_access_block(self, Bucket: str):
        pass

    def get_bucket_accelerate_configuration(self, Bucket: str) -> GetBucketAccelerateConfigurationOutput:
        pass

    def get_bucket_acl(self, Bucket: str) -> GetBucketAclOutput:
        pass

    def get_bucket_analytics_configuration(self, Id: str, Bucket: str) -> GetBucketAnalyticsConfigurationOutput:
        pass

    def get_bucket_cors(self, Bucket: str) -> GetBucketCorsOutput:
        pass

    def get_bucket_encryption(self, Bucket: str) -> GetBucketEncryptionOutput:
        pass

    def get_bucket_inventory_configuration(self, Id: str, Bucket: str) -> GetBucketInventoryConfigurationOutput:
        pass

    def get_bucket_lifecycle(self, Bucket: str) -> GetBucketLifecycleOutput:
        pass

    def get_bucket_lifecycle_configuration(self, Bucket: str) -> GetBucketLifecycleConfigurationOutput:
        pass

    def get_bucket_location(self, Bucket: str) -> GetBucketLocationOutput:
        pass

    def get_bucket_logging(self, Bucket: str) -> GetBucketLoggingOutput:
        pass

    def get_bucket_metrics_configuration(self, Id: str, Bucket: str) -> GetBucketMetricsConfigurationOutput:
        pass

    def get_bucket_notification(self, Bucket: str) -> NotificationConfigurationDeprecated:
        pass

    def get_bucket_notification_configuration(self, Bucket: str) -> NotificationConfiguration:
        pass

    def get_bucket_policy(self, Bucket: str) -> GetBucketPolicyOutput:
        pass

    def get_bucket_policy_status(self, Bucket: str) -> GetBucketPolicyStatusOutput:
        pass

    def get_bucket_replication(self, Bucket: str) -> GetBucketReplicationOutput:
        pass

    def get_bucket_request_payment(self, Bucket: str) -> GetBucketRequestPaymentOutput:
        pass

    def get_bucket_tagging(self, Bucket: str) -> GetBucketTaggingOutput:
        pass

    def get_bucket_versioning(self, Bucket: str) -> GetBucketVersioningOutput:
        pass

    def get_bucket_website(self, Bucket: str) -> GetBucketWebsiteOutput:
        pass

    def get_object(self, Key: str, Bucket: str, IfMatch: str=None, IfModifiedSince: IfModifiedSince=None, IfNoneMatch: str=None, IfUnmodifiedSince: IfUnmodifiedSince=None, Range: str=None, ResponseCacheControl: str=None, ResponseContentDisposition: str=None, ResponseContentEncoding: str=None, ResponseContentLanguage: str=None, ResponseContentType: str=None, ResponseExpires: ResponseExpires=None, VersionId: str=None, SSECustomerAlgorithm: str=None, SSECustomerKey: str=None, SSECustomerKeyMD5: str=None, RequestPayer: str=None, PartNumber: int=None) -> GetObjectOutput:
        pass

    def get_object_acl(self, Key: str, Bucket: str, VersionId: str=None, RequestPayer: str=None) -> GetObjectAclOutput:
        pass

    def get_object_legal_hold(self, Key: str, Bucket: str, VersionId: str=None, RequestPayer: str=None) -> GetObjectLegalHoldOutput:
        pass

    def get_object_lock_configuration(self, Bucket: str) -> GetObjectLockConfigurationOutput:
        pass

    def get_object_retention(self, Key: str, Bucket: str, VersionId: str=None, RequestPayer: str=None) -> GetObjectRetentionOutput:
        pass

    def get_object_tagging(self, Key: str, Bucket: str, VersionId: str=None) -> GetObjectTaggingOutput:
        pass

    def get_object_torrent(self, Key: str, Bucket: str, RequestPayer: str=None) -> GetObjectTorrentOutput:
        pass

    def get_public_access_block(self, Bucket: str) -> GetPublicAccessBlockOutput:
        pass

    def head_bucket(self, Bucket: str):
        pass

    def head_object(self, Key: str, Bucket: str, IfMatch: str=None, IfModifiedSince: IfModifiedSince=None, IfNoneMatch: str=None, IfUnmodifiedSince: IfUnmodifiedSince=None, Range: str=None, VersionId: str=None, SSECustomerAlgorithm: str=None, SSECustomerKey: str=None, SSECustomerKeyMD5: str=None, RequestPayer: str=None, PartNumber: int=None) -> HeadObjectOutput:
        pass

    def list_bucket_analytics_configurations(self, Bucket: str, ContinuationToken: str=None) -> ListBucketAnalyticsConfigurationsOutput:
        pass

    def list_bucket_inventory_configurations(self, Bucket: str, ContinuationToken: str=None) -> ListBucketInventoryConfigurationsOutput:
        pass

    def list_bucket_metrics_configurations(self, Bucket: str, ContinuationToken: str=None) -> ListBucketMetricsConfigurationsOutput:
        pass

    def list_buckets(self) -> ListBucketsOutput:
        pass

    def list_multipart_uploads(self, Bucket: str, Delimiter: str=None, EncodingType: str=None, KeyMarker: str=None, MaxUploads: int=None, Prefix: str=None, UploadIdMarker: str=None) -> ListMultipartUploadsOutput:
        pass

    def list_object_versions(self, Bucket: str, Delimiter: str=None, EncodingType: str=None, KeyMarker: str=None, MaxKeys: int=None, Prefix: str=None, VersionIdMarker: str=None) -> ListObjectVersionsOutput:
        pass

    def list_objects(self, Bucket: str, Delimiter: str=None, EncodingType: str=None, Marker: str=None, MaxKeys: int=None, Prefix: str=None, RequestPayer: str=None) -> ListObjectsOutput:
        pass

    def list_objects_v2(self, Bucket: str, Delimiter: str=None, EncodingType: str=None, MaxKeys: int=None, Prefix: str=None, ContinuationToken: str=None, FetchOwner: FetchOwner=None, StartAfter: str=None, RequestPayer: str=None) -> ListObjectsV2Output:
        pass

    def list_parts(self, UploadId: str, Key: str, Bucket: str, MaxParts: int=None, PartNumberMarker: int=None, RequestPayer: str=None) -> ListPartsOutput:
        pass

    def put_bucket_accelerate_configuration(self, AccelerateConfiguration: AccelerateConfiguration, Bucket: str):
        pass

    def put_bucket_acl(self, Bucket: str, ACL: str=None, AccessControlPolicy: AccessControlPolicy=None, ContentMD5: str=None, GrantFullControl: str=None, GrantRead: str=None, GrantReadACP: str=None, GrantWrite: str=None, GrantWriteACP: str=None):
        pass

    def put_bucket_analytics_configuration(self, AnalyticsConfiguration: AnalyticsConfiguration, Id: str, Bucket: str):
        pass

    def put_bucket_cors(self, CORSConfiguration: CORSConfiguration, Bucket: str, ContentMD5: str=None):
        pass

    def put_bucket_encryption(self, ServerSideEncryptionConfiguration: ServerSideEncryptionConfiguration, Bucket: str, ContentMD5: str=None):
        pass

    def put_bucket_inventory_configuration(self, InventoryConfiguration: InventoryConfiguration, Id: str, Bucket: str):
        pass

    def put_bucket_lifecycle(self, Bucket: str, ContentMD5: str=None, LifecycleConfiguration: LifecycleConfiguration=None):
        pass

    def put_bucket_lifecycle_configuration(self, Bucket: str, LifecycleConfiguration: BucketLifecycleConfiguration=None):
        pass

    def put_bucket_logging(self, BucketLoggingStatus: BucketLoggingStatus, Bucket: str, ContentMD5: str=None):
        pass

    def put_bucket_metrics_configuration(self, MetricsConfiguration: MetricsConfiguration, Id: str, Bucket: str):
        pass

    def put_bucket_notification(self, NotificationConfiguration: NotificationConfigurationDeprecated, Bucket: str, ContentMD5: str=None):
        pass

    def put_bucket_notification_configuration(self, NotificationConfiguration: NotificationConfiguration, Bucket: str):
        pass

    def put_bucket_policy(self, Policy: str, Bucket: str, ContentMD5: str=None, ConfirmRemoveSelfBucketAccess: ConfirmRemoveSelfBucketAccess=None):
        pass

    def put_bucket_replication(self, ReplicationConfiguration: ReplicationConfiguration, Bucket: str, ContentMD5: str=None):
        pass

    def put_bucket_request_payment(self, RequestPaymentConfiguration: RequestPaymentConfiguration, Bucket: str, ContentMD5: str=None):
        pass

    def put_bucket_tagging(self, Tagging: Tagging, Bucket: str, ContentMD5: str=None):
        pass

    def put_bucket_versioning(self, VersioningConfiguration: VersioningConfiguration, Bucket: str, ContentMD5: str=None, MFA: str=None):
        pass

    def put_bucket_website(self, WebsiteConfiguration: WebsiteConfiguration, Bucket: str, ContentMD5: str=None):
        pass

    def put_object(self, Key: str, Bucket: str, ACL: str=None, Body: Body=None, CacheControl: str=None, ContentDisposition: str=None, ContentEncoding: str=None, ContentLanguage: str=None, ContentLength: ContentLength=None, ContentMD5: str=None, ContentType: str=None, Expires: Expires=None, GrantFullControl: str=None, GrantRead: str=None, GrantReadACP: str=None, GrantWriteACP: str=None, Metadata: Metadata=None, ServerSideEncryption: str=None, StorageClass: str=None, WebsiteRedirectLocation: str=None, SSECustomerAlgorithm: str=None, SSECustomerKey: str=None, SSECustomerKeyMD5: str=None, SSEKMSKeyId: str=None, RequestPayer: str=None, Tagging: str=None, ObjectLockMode: str=None, ObjectLockRetainUntilDate: ObjectLockRetainUntilDate=None, ObjectLockLegalHoldStatus: str=None) -> PutObjectOutput:
        pass

    def put_object_acl(self, Key: str, Bucket: str, ACL: str=None, AccessControlPolicy: AccessControlPolicy=None, ContentMD5: str=None, GrantFullControl: str=None, GrantRead: str=None, GrantReadACP: str=None, GrantWrite: str=None, GrantWriteACP: str=None, RequestPayer: str=None, VersionId: str=None) -> PutObjectAclOutput:
        pass

    def put_object_legal_hold(self, Key: str, Bucket: str, LegalHold: ObjectLockLegalHold=None, RequestPayer: str=None, VersionId: str=None, ContentMD5: str=None) -> PutObjectLegalHoldOutput:
        pass

    def put_object_lock_configuration(self, Bucket: str, ObjectLockConfiguration: ObjectLockConfiguration=None, RequestPayer: str=None, Token: str=None, ContentMD5: str=None) -> PutObjectLockConfigurationOutput:
        pass

    def put_object_retention(self, Key: str, Bucket: str, Retention: ObjectLockRetention=None, RequestPayer: str=None, VersionId: str=None, BypassGovernanceRetention: BypassGovernanceRetention=None, ContentMD5: str=None) -> PutObjectRetentionOutput:
        pass

    def put_object_tagging(self, Tagging: Tagging, Key: str, Bucket: str, VersionId: str=None, ContentMD5: str=None) -> PutObjectTaggingOutput:
        pass

    def put_public_access_block(self, PublicAccessBlockConfiguration: PublicAccessBlockConfiguration, Bucket: str, ContentMD5: str=None):
        pass

    def restore_object(self, Key: str, Bucket: str, VersionId: str=None, RestoreRequest: RestoreRequest=None, RequestPayer: str=None) -> RestoreObjectOutput:
        pass

    def select_object_content(self, OutputSerialization: OutputSerialization, InputSerialization: InputSerialization, ExpressionType: str, Expression: str, Key: str, Bucket: str, SSECustomerAlgorithm: str=None, SSECustomerKey: str=None, SSECustomerKeyMD5: str=None, RequestProgress: RequestProgress=None) -> SelectObjectContentOutput:
        pass

    def upload_part(self, UploadId: str, PartNumber: int, Key: str, Bucket: str, Body: Body=None, ContentLength: ContentLength=None, ContentMD5: str=None, SSECustomerAlgorithm: str=None, SSECustomerKey: str=None, SSECustomerKeyMD5: str=None, RequestPayer: str=None) -> UploadPartOutput:
        pass

    def upload_part_copy(self, UploadId: str, PartNumber: int, Key: str, CopySource: str, Bucket: str, CopySourceIfMatch: str=None, CopySourceIfModifiedSince: CopySourceIfModifiedSince=None, CopySourceIfNoneMatch: str=None, CopySourceIfUnmodifiedSince: CopySourceIfUnmodifiedSince=None, CopySourceRange: str=None, SSECustomerAlgorithm: str=None, SSECustomerKey: str=None, SSECustomerKeyMD5: str=None, CopySourceSSECustomerAlgorithm: str=None, CopySourceSSECustomerKey: str=None, CopySourceSSECustomerKeyMD5: str=None, RequestPayer: str=None) -> UploadPartCopyOutput:
        pass


class S3Control(BaseClient):
    class DeletePublicAccessBlockRequest(Mapping):
        pass

    class GetPublicAccessBlockRequest(Mapping):
        pass

    class GetPublicAccessBlockOutput(Mapping):
        pass

    class PutPublicAccessBlockRequest(Mapping):
        pass

    class PublicAccessBlockConfiguration(Mapping):
        pass

    def delete_public_access_block(self, AccountId: str):
        pass

    def get_public_access_block(self, AccountId: str) -> GetPublicAccessBlockOutput:
        pass

    def put_public_access_block(self, AccountId: str, PublicAccessBlockConfiguration: PublicAccessBlockConfiguration):
        pass


class SageMaker(BaseClient):
    class AddTagsInput(Mapping):
        pass

    class AddTagsOutput(Mapping):
        pass

    class Tag(Mapping):
        pass

    class CreateAlgorithmInput(Mapping):
        pass

    class CreateAlgorithmOutput(Mapping):
        pass

    class TrainingSpecification(Mapping):
        pass

    class InferenceSpecification(Mapping):
        pass

    class AlgorithmValidationSpecification(Mapping):
        pass

    class CertifyForMarketplace(object):
        pass

    class CreateCodeRepositoryInput(Mapping):
        pass

    class CreateCodeRepositoryOutput(Mapping):
        pass

    class GitConfig(Mapping):
        pass

    class CreateCompilationJobRequest(Mapping):
        pass

    class CreateCompilationJobResponse(Mapping):
        pass

    class InputConfig(Mapping):
        pass

    class OutputConfig(Mapping):
        pass

    class StoppingCondition(Mapping):
        pass

    class CreateEndpointInput(Mapping):
        pass

    class CreateEndpointOutput(Mapping):
        pass

    class CreateEndpointConfigInput(Mapping):
        pass

    class CreateEndpointConfigOutput(Mapping):
        pass

    class ProductionVariant(Mapping):
        pass

    class CreateHyperParameterTuningJobRequest(Mapping):
        pass

    class CreateHyperParameterTuningJobResponse(Mapping):
        pass

    class HyperParameterTuningJobConfig(Mapping):
        pass

    class HyperParameterTrainingJobDefinition(Mapping):
        pass

    class HyperParameterTuningJobWarmStartConfig(Mapping):
        pass

    class CreateLabelingJobRequest(Mapping):
        pass

    class CreateLabelingJobResponse(Mapping):
        pass

    class LabelingJobInputConfig(Mapping):
        pass

    class LabelingJobOutputConfig(Mapping):
        pass

    class LabelingJobStoppingConditions(Mapping):
        pass

    class LabelingJobAlgorithmsConfig(Mapping):
        pass

    class HumanTaskConfig(Mapping):
        pass

    class CreateModelInput(Mapping):
        pass

    class CreateModelOutput(Mapping):
        pass

    class ContainerDefinition(Mapping):
        pass

    class VpcConfig(Mapping):
        pass

    class Boolean(object):
        pass

    class CreateModelPackageInput(Mapping):
        pass

    class CreateModelPackageOutput(Mapping):
        pass

    class ModelPackageValidationSpecification(Mapping):
        pass

    class SourceAlgorithmSpecification(Mapping):
        pass

    class CreateNotebookInstanceInput(Mapping):
        pass

    class CreateNotebookInstanceOutput(Mapping):
        pass

    class SecurityGroupId(object):
        pass

    class NotebookInstanceAcceleratorType(object):
        pass

    class CodeRepositoryNameOrUrl(object):
        pass

    class CreateNotebookInstanceLifecycleConfigInput(Mapping):
        pass

    class CreateNotebookInstanceLifecycleConfigOutput(Mapping):
        pass

    class NotebookInstanceLifecycleHook(Mapping):
        pass

    class CreatePresignedNotebookInstanceUrlInput(Mapping):
        pass

    class CreatePresignedNotebookInstanceUrlOutput(Mapping):
        pass

    class CreateTrainingJobRequest(Mapping):
        pass

    class CreateTrainingJobResponse(Mapping):
        pass

    class HyperParameters(object):
        pass

    class AlgorithmSpecification(Mapping):
        pass

    class Channel(Mapping):
        pass

    class OutputDataConfig(Mapping):
        pass

    class ResourceConfig(Mapping):
        pass

    class CreateTransformJobRequest(Mapping):
        pass

    class CreateTransformJobResponse(Mapping):
        pass

    class TransformEnvironmentMap(object):
        pass

    class TransformInput(Mapping):
        pass

    class TransformOutput(Mapping):
        pass

    class TransformResources(Mapping):
        pass

    class CreateWorkteamRequest(Mapping):
        pass

    class CreateWorkteamResponse(Mapping):
        pass

    class MemberDefinition(Mapping):
        pass

    class DeleteAlgorithmInput(Mapping):
        pass

    class DeleteCodeRepositoryInput(Mapping):
        pass

    class DeleteEndpointInput(Mapping):
        pass

    class DeleteEndpointConfigInput(Mapping):
        pass

    class DeleteModelInput(Mapping):
        pass

    class DeleteModelPackageInput(Mapping):
        pass

    class DeleteNotebookInstanceInput(Mapping):
        pass

    class DeleteNotebookInstanceLifecycleConfigInput(Mapping):
        pass

    class DeleteTagsInput(Mapping):
        pass

    class DeleteTagsOutput(Mapping):
        pass

    class TagKey(object):
        pass

    class DeleteWorkteamRequest(Mapping):
        pass

    class DeleteWorkteamResponse(Mapping):
        pass

    class DescribeAlgorithmInput(Mapping):
        pass

    class DescribeAlgorithmOutput(Mapping):
        pass

    class DescribeCodeRepositoryInput(Mapping):
        pass

    class DescribeCodeRepositoryOutput(Mapping):
        pass

    class DescribeCompilationJobRequest(Mapping):
        pass

    class DescribeCompilationJobResponse(Mapping):
        pass

    class DescribeEndpointInput(Mapping):
        pass

    class DescribeEndpointOutput(Mapping):
        pass

    class DescribeEndpointConfigInput(Mapping):
        pass

    class DescribeEndpointConfigOutput(Mapping):
        pass

    class DescribeHyperParameterTuningJobRequest(Mapping):
        pass

    class DescribeHyperParameterTuningJobResponse(Mapping):
        pass

    class DescribeLabelingJobRequest(Mapping):
        pass

    class DescribeLabelingJobResponse(Mapping):
        pass

    class DescribeModelInput(Mapping):
        pass

    class DescribeModelOutput(Mapping):
        pass

    class DescribeModelPackageInput(Mapping):
        pass

    class DescribeModelPackageOutput(Mapping):
        pass

    class DescribeNotebookInstanceInput(Mapping):
        pass

    class DescribeNotebookInstanceOutput(Mapping):
        pass

    class DescribeNotebookInstanceLifecycleConfigInput(Mapping):
        pass

    class DescribeNotebookInstanceLifecycleConfigOutput(Mapping):
        pass

    class DescribeSubscribedWorkteamRequest(Mapping):
        pass

    class DescribeSubscribedWorkteamResponse(Mapping):
        pass

    class DescribeTrainingJobRequest(Mapping):
        pass

    class DescribeTrainingJobResponse(Mapping):
        pass

    class DescribeTransformJobRequest(Mapping):
        pass

    class DescribeTransformJobResponse(Mapping):
        pass

    class DescribeWorkteamRequest(Mapping):
        pass

    class DescribeWorkteamResponse(Mapping):
        pass

    class GetSearchSuggestionsRequest(Mapping):
        pass

    class GetSearchSuggestionsResponse(Mapping):
        pass

    class SuggestionQuery(Mapping):
        pass

    class ListAlgorithmsInput(Mapping):
        pass

    class ListAlgorithmsOutput(Mapping):
        pass

    class CreationTime(object):
        pass

    class ListCodeRepositoriesInput(Mapping):
        pass

    class ListCodeRepositoriesOutput(Mapping):
        pass

    class Timestamp(object):
        pass

    class ListCompilationJobsRequest(Mapping):
        pass

    class ListCompilationJobsResponse(Mapping):
        pass

    class LastModifiedTime(object):
        pass

    class ListEndpointConfigsInput(Mapping):
        pass

    class ListEndpointConfigsOutput(Mapping):
        pass

    class ListEndpointsInput(Mapping):
        pass

    class ListEndpointsOutput(Mapping):
        pass

    class ListHyperParameterTuningJobsRequest(Mapping):
        pass

    class ListHyperParameterTuningJobsResponse(Mapping):
        pass

    class ListLabelingJobsRequest(Mapping):
        pass

    class ListLabelingJobsResponse(Mapping):
        pass

    class ListLabelingJobsForWorkteamRequest(Mapping):
        pass

    class ListLabelingJobsForWorkteamResponse(Mapping):
        pass

    class ListModelPackagesInput(Mapping):
        pass

    class ListModelPackagesOutput(Mapping):
        pass

    class ListModelsInput(Mapping):
        pass

    class ListModelsOutput(Mapping):
        pass

    class ListNotebookInstanceLifecycleConfigsInput(Mapping):
        pass

    class ListNotebookInstanceLifecycleConfigsOutput(Mapping):
        pass

    class ListNotebookInstancesInput(Mapping):
        pass

    class ListNotebookInstancesOutput(Mapping):
        pass

    class ListSubscribedWorkteamsRequest(Mapping):
        pass

    class ListSubscribedWorkteamsResponse(Mapping):
        pass

    class ListTagsInput(Mapping):
        pass

    class ListTagsOutput(Mapping):
        pass

    class ListTrainingJobsRequest(Mapping):
        pass

    class ListTrainingJobsResponse(Mapping):
        pass

    class ListTrainingJobsForHyperParameterTuningJobRequest(Mapping):
        pass

    class ListTrainingJobsForHyperParameterTuningJobResponse(Mapping):
        pass

    class ListTransformJobsRequest(Mapping):
        pass

    class ListTransformJobsResponse(Mapping):
        pass

    class ListWorkteamsRequest(Mapping):
        pass

    class ListWorkteamsResponse(Mapping):
        pass

    class RenderUiTemplateRequest(Mapping):
        pass

    class RenderUiTemplateResponse(Mapping):
        pass

    class UiTemplate(Mapping):
        pass

    class RenderableTask(Mapping):
        pass

    class SearchRequest(Mapping):
        pass

    class SearchResponse(Mapping):
        pass

    class SearchExpression(Mapping):
        pass

    class StartNotebookInstanceInput(Mapping):
        pass

    class StopCompilationJobRequest(Mapping):
        pass

    class StopHyperParameterTuningJobRequest(Mapping):
        pass

    class StopLabelingJobRequest(Mapping):
        pass

    class StopNotebookInstanceInput(Mapping):
        pass

    class StopTrainingJobRequest(Mapping):
        pass

    class StopTransformJobRequest(Mapping):
        pass

    class UpdateCodeRepositoryInput(Mapping):
        pass

    class UpdateCodeRepositoryOutput(Mapping):
        pass

    class GitConfigForUpdate(Mapping):
        pass

    class UpdateEndpointInput(Mapping):
        pass

    class UpdateEndpointOutput(Mapping):
        pass

    class UpdateEndpointWeightsAndCapacitiesInput(Mapping):
        pass

    class UpdateEndpointWeightsAndCapacitiesOutput(Mapping):
        pass

    class DesiredWeightAndCapacity(Mapping):
        pass

    class UpdateNotebookInstanceInput(Mapping):
        pass

    class UpdateNotebookInstanceOutput(Mapping):
        pass

    class DisassociateNotebookInstanceLifecycleConfig(object):
        pass

    class DisassociateNotebookInstanceAcceleratorTypes(object):
        pass

    class DisassociateDefaultCodeRepository(object):
        pass

    class DisassociateAdditionalCodeRepositories(object):
        pass

    class UpdateNotebookInstanceLifecycleConfigInput(Mapping):
        pass

    class UpdateNotebookInstanceLifecycleConfigOutput(Mapping):
        pass

    class UpdateWorkteamRequest(Mapping):
        pass

    class UpdateWorkteamResponse(Mapping):
        pass

    def add_tags(self, Tags: List[Tag], ResourceArn: str) -> AddTagsOutput:
        pass

    def create_algorithm(self, TrainingSpecification: TrainingSpecification, AlgorithmName: str, AlgorithmDescription: str=None, InferenceSpecification: InferenceSpecification=None, ValidationSpecification: AlgorithmValidationSpecification=None, CertifyForMarketplace: CertifyForMarketplace=None) -> CreateAlgorithmOutput:
        pass

    def create_code_repository(self, GitConfig: GitConfig, CodeRepositoryName: str) -> CreateCodeRepositoryOutput:
        pass

    def create_compilation_job(self, StoppingCondition: StoppingCondition, OutputConfig: OutputConfig, InputConfig: InputConfig, RoleArn: str, CompilationJobName: str) -> CreateCompilationJobResponse:
        pass

    def create_endpoint(self, EndpointConfigName: str, EndpointName: str, Tags: List[Tag]=None) -> CreateEndpointOutput:
        pass

    def create_endpoint_config(self, ProductionVariants: List[ProductionVariant], EndpointConfigName: str, Tags: List[Tag]=None, KmsKeyId: str=None) -> CreateEndpointConfigOutput:
        pass

    def create_hyper_parameter_tuning_job(self, TrainingJobDefinition: HyperParameterTrainingJobDefinition, HyperParameterTuningJobConfig: HyperParameterTuningJobConfig, HyperParameterTuningJobName: str, WarmStartConfig: HyperParameterTuningJobWarmStartConfig=None, Tags: List[Tag]=None) -> CreateHyperParameterTuningJobResponse:
        pass

    def create_labeling_job(self, HumanTaskConfig: HumanTaskConfig, RoleArn: str, OutputConfig: LabelingJobOutputConfig, InputConfig: LabelingJobInputConfig, LabelAttributeName: str, LabelingJobName: str, LabelCategoryConfigS3Uri: str=None, StoppingConditions: LabelingJobStoppingConditions=None, LabelingJobAlgorithmsConfig: LabelingJobAlgorithmsConfig=None, Tags: List[Tag]=None) -> CreateLabelingJobResponse:
        pass

    def create_model(self, ExecutionRoleArn: str, ModelName: str, PrimaryContainer: ContainerDefinition=None, Containers: List[ContainerDefinition]=None, Tags: List[Tag]=None, VpcConfig: VpcConfig=None, EnableNetworkIsolation: Boolean=None) -> CreateModelOutput:
        pass

    def create_model_package(self, ModelPackageName: str, ModelPackageDescription: str=None, InferenceSpecification: InferenceSpecification=None, ValidationSpecification: ModelPackageValidationSpecification=None, SourceAlgorithmSpecification: SourceAlgorithmSpecification=None, CertifyForMarketplace: CertifyForMarketplace=None) -> CreateModelPackageOutput:
        pass

    def create_notebook_instance(self, RoleArn: str, InstanceType: str, NotebookInstanceName: str, SubnetId: str=None, SecurityGroupIds: List[SecurityGroupId]=None, KmsKeyId: str=None, Tags: List[Tag]=None, LifecycleConfigName: str=None, DirectInternetAccess: str=None, VolumeSizeInGB: int=None, AcceleratorTypes: List[NotebookInstanceAcceleratorType]=None, DefaultCodeRepository: str=None, AdditionalCodeRepositories: List[CodeRepositoryNameOrUrl]=None) -> CreateNotebookInstanceOutput:
        pass

    def create_notebook_instance_lifecycle_config(self, NotebookInstanceLifecycleConfigName: str, OnCreate: List[NotebookInstanceLifecycleHook]=None, OnStart: List[NotebookInstanceLifecycleHook]=None) -> CreateNotebookInstanceLifecycleConfigOutput:
        pass

    def create_presigned_notebook_instance_url(self, NotebookInstanceName: str, SessionExpirationDurationInSeconds: int=None) -> CreatePresignedNotebookInstanceUrlOutput:
        pass

    def create_training_job(self, StoppingCondition: StoppingCondition, ResourceConfig: ResourceConfig, OutputDataConfig: OutputDataConfig, RoleArn: str, AlgorithmSpecification: AlgorithmSpecification, TrainingJobName: str, HyperParameters: HyperParameters=None, InputDataConfig: List[Channel]=None, VpcConfig: VpcConfig=None, Tags: List[Tag]=None, EnableNetworkIsolation: Boolean=None, EnableInterContainerTrafficEncryption: Boolean=None) -> CreateTrainingJobResponse:
        pass

    def create_transform_job(self, TransformResources: TransformResources, TransformOutput: TransformOutput, TransformInput: TransformInput, ModelName: str, TransformJobName: str, MaxConcurrentTransforms: int=None, MaxPayloadInMB: int=None, BatchStrategy: str=None, Environment: TransformEnvironmentMap=None, Tags: List[Tag]=None) -> CreateTransformJobResponse:
        pass

    def create_workteam(self, Description: str, MemberDefinitions: List[MemberDefinition], WorkteamName: str, Tags: List[Tag]=None) -> CreateWorkteamResponse:
        pass

    def delete_algorithm(self, AlgorithmName: str):
        pass

    def delete_code_repository(self, CodeRepositoryName: str):
        pass

    def delete_endpoint(self, EndpointName: str):
        pass

    def delete_endpoint_config(self, EndpointConfigName: str):
        pass

    def delete_model(self, ModelName: str):
        pass

    def delete_model_package(self, ModelPackageName: str):
        pass

    def delete_notebook_instance(self, NotebookInstanceName: str):
        pass

    def delete_notebook_instance_lifecycle_config(self, NotebookInstanceLifecycleConfigName: str):
        pass

    def delete_tags(self, TagKeys: List[TagKey], ResourceArn: str) -> DeleteTagsOutput:
        pass

    def delete_workteam(self, WorkteamName: str) -> DeleteWorkteamResponse:
        pass

    def describe_algorithm(self, AlgorithmName: str) -> DescribeAlgorithmOutput:
        pass

    def describe_code_repository(self, CodeRepositoryName: str) -> DescribeCodeRepositoryOutput:
        pass

    def describe_compilation_job(self, CompilationJobName: str) -> DescribeCompilationJobResponse:
        pass

    def describe_endpoint(self, EndpointName: str) -> DescribeEndpointOutput:
        pass

    def describe_endpoint_config(self, EndpointConfigName: str) -> DescribeEndpointConfigOutput:
        pass

    def describe_hyper_parameter_tuning_job(self, HyperParameterTuningJobName: str) -> DescribeHyperParameterTuningJobResponse:
        pass

    def describe_labeling_job(self, LabelingJobName: str) -> DescribeLabelingJobResponse:
        pass

    def describe_model(self, ModelName: str) -> DescribeModelOutput:
        pass

    def describe_model_package(self, ModelPackageName: str) -> DescribeModelPackageOutput:
        pass

    def describe_notebook_instance(self, NotebookInstanceName: str) -> DescribeNotebookInstanceOutput:
        pass

    def describe_notebook_instance_lifecycle_config(self, NotebookInstanceLifecycleConfigName: str) -> DescribeNotebookInstanceLifecycleConfigOutput:
        pass

    def describe_subscribed_workteam(self, WorkteamArn: str) -> DescribeSubscribedWorkteamResponse:
        pass

    def describe_training_job(self, TrainingJobName: str) -> DescribeTrainingJobResponse:
        pass

    def describe_transform_job(self, TransformJobName: str) -> DescribeTransformJobResponse:
        pass

    def describe_workteam(self, WorkteamName: str) -> DescribeWorkteamResponse:
        pass

    def get_search_suggestions(self, Resource: str, SuggestionQuery: SuggestionQuery=None) -> GetSearchSuggestionsResponse:
        pass

    def list_algorithms(self, CreationTimeAfter: CreationTime=None, CreationTimeBefore: CreationTime=None, MaxResults: int=None, NameContains: str=None, NextToken: str=None, SortBy: str=None, SortOrder: str=None) -> ListAlgorithmsOutput:
        pass

    def list_code_repositories(self, CreationTimeAfter: CreationTime=None, CreationTimeBefore: CreationTime=None, LastModifiedTimeAfter: Timestamp=None, LastModifiedTimeBefore: Timestamp=None, MaxResults: int=None, NameContains: str=None, NextToken: str=None, SortBy: str=None, SortOrder: str=None) -> ListCodeRepositoriesOutput:
        pass

    def list_compilation_jobs(self, NextToken: str=None, MaxResults: int=None, CreationTimeAfter: CreationTime=None, CreationTimeBefore: CreationTime=None, LastModifiedTimeAfter: LastModifiedTime=None, LastModifiedTimeBefore: LastModifiedTime=None, NameContains: str=None, StatusEquals: str=None, SortBy: str=None, SortOrder: str=None) -> ListCompilationJobsResponse:
        pass

    def list_endpoint_configs(self, SortBy: str=None, SortOrder: str=None, NextToken: str=None, MaxResults: int=None, NameContains: str=None, CreationTimeBefore: Timestamp=None, CreationTimeAfter: Timestamp=None) -> ListEndpointConfigsOutput:
        pass

    def list_endpoints(self, SortBy: str=None, SortOrder: str=None, NextToken: str=None, MaxResults: int=None, NameContains: str=None, CreationTimeBefore: Timestamp=None, CreationTimeAfter: Timestamp=None, LastModifiedTimeBefore: Timestamp=None, LastModifiedTimeAfter: Timestamp=None, StatusEquals: str=None) -> ListEndpointsOutput:
        pass

    def list_hyper_parameter_tuning_jobs(self, NextToken: str=None, MaxResults: int=None, SortBy: str=None, SortOrder: str=None, NameContains: str=None, CreationTimeAfter: Timestamp=None, CreationTimeBefore: Timestamp=None, LastModifiedTimeAfter: Timestamp=None, LastModifiedTimeBefore: Timestamp=None, StatusEquals: str=None) -> ListHyperParameterTuningJobsResponse:
        pass

    def list_labeling_jobs(self, CreationTimeAfter: Timestamp=None, CreationTimeBefore: Timestamp=None, LastModifiedTimeAfter: Timestamp=None, LastModifiedTimeBefore: Timestamp=None, MaxResults: int=None, NextToken: str=None, NameContains: str=None, SortBy: str=None, SortOrder: str=None, StatusEquals: str=None) -> ListLabelingJobsResponse:
        pass

    def list_labeling_jobs_for_workteam(self, WorkteamArn: str, MaxResults: int=None, NextToken: str=None, CreationTimeAfter: Timestamp=None, CreationTimeBefore: Timestamp=None, JobReferenceCodeContains: str=None, SortBy: str=None, SortOrder: str=None) -> ListLabelingJobsForWorkteamResponse:
        pass

    def list_model_packages(self, CreationTimeAfter: CreationTime=None, CreationTimeBefore: CreationTime=None, MaxResults: int=None, NameContains: str=None, NextToken: str=None, SortBy: str=None, SortOrder: str=None) -> ListModelPackagesOutput:
        pass

    def list_models(self, SortBy: str=None, SortOrder: str=None, NextToken: str=None, MaxResults: int=None, NameContains: str=None, CreationTimeBefore: Timestamp=None, CreationTimeAfter: Timestamp=None) -> ListModelsOutput:
        pass

    def list_notebook_instance_lifecycle_configs(self, NextToken: str=None, MaxResults: int=None, SortBy: str=None, SortOrder: str=None, NameContains: str=None, CreationTimeBefore: CreationTime=None, CreationTimeAfter: CreationTime=None, LastModifiedTimeBefore: LastModifiedTime=None, LastModifiedTimeAfter: LastModifiedTime=None) -> ListNotebookInstanceLifecycleConfigsOutput:
        pass

    def list_notebook_instances(self, NextToken: str=None, MaxResults: int=None, SortBy: str=None, SortOrder: str=None, NameContains: str=None, CreationTimeBefore: CreationTime=None, CreationTimeAfter: CreationTime=None, LastModifiedTimeBefore: LastModifiedTime=None, LastModifiedTimeAfter: LastModifiedTime=None, StatusEquals: str=None, NotebookInstanceLifecycleConfigNameContains: str=None, DefaultCodeRepositoryContains: str=None, AdditionalCodeRepositoryEquals: str=None) -> ListNotebookInstancesOutput:
        pass

    def list_subscribed_workteams(self, NameContains: str=None, NextToken: str=None, MaxResults: int=None) -> ListSubscribedWorkteamsResponse:
        pass

    def list_tags(self, ResourceArn: str, NextToken: str=None, MaxResults: int=None) -> ListTagsOutput:
        pass

    def list_training_jobs(self, NextToken: str=None, MaxResults: int=None, CreationTimeAfter: Timestamp=None, CreationTimeBefore: Timestamp=None, LastModifiedTimeAfter: Timestamp=None, LastModifiedTimeBefore: Timestamp=None, NameContains: str=None, StatusEquals: str=None, SortBy: str=None, SortOrder: str=None) -> ListTrainingJobsResponse:
        pass

    def list_training_jobs_for_hyper_parameter_tuning_job(self, HyperParameterTuningJobName: str, NextToken: str=None, MaxResults: int=None, StatusEquals: str=None, SortBy: str=None, SortOrder: str=None) -> ListTrainingJobsForHyperParameterTuningJobResponse:
        pass

    def list_transform_jobs(self, CreationTimeAfter: Timestamp=None, CreationTimeBefore: Timestamp=None, LastModifiedTimeAfter: Timestamp=None, LastModifiedTimeBefore: Timestamp=None, NameContains: str=None, StatusEquals: str=None, SortBy: str=None, SortOrder: str=None, NextToken: str=None, MaxResults: int=None) -> ListTransformJobsResponse:
        pass

    def list_workteams(self, SortBy: str=None, SortOrder: str=None, NameContains: str=None, NextToken: str=None, MaxResults: int=None) -> ListWorkteamsResponse:
        pass

    def render_ui_template(self, RoleArn: str, Task: RenderableTask, UiTemplate: UiTemplate) -> RenderUiTemplateResponse:
        pass

    def search(self, Resource: str, SearchExpression: SearchExpression=None, SortBy: str=None, SortOrder: str=None, NextToken: str=None, MaxResults: int=None) -> SearchResponse:
        pass

    def start_notebook_instance(self, NotebookInstanceName: str):
        pass

    def stop_compilation_job(self, CompilationJobName: str):
        pass

    def stop_hyper_parameter_tuning_job(self, HyperParameterTuningJobName: str):
        pass

    def stop_labeling_job(self, LabelingJobName: str):
        pass

    def stop_notebook_instance(self, NotebookInstanceName: str):
        pass

    def stop_training_job(self, TrainingJobName: str):
        pass

    def stop_transform_job(self, TransformJobName: str):
        pass

    def update_code_repository(self, CodeRepositoryName: str, GitConfig: GitConfigForUpdate=None) -> UpdateCodeRepositoryOutput:
        pass

    def update_endpoint(self, EndpointConfigName: str, EndpointName: str) -> UpdateEndpointOutput:
        pass

    def update_endpoint_weights_and_capacities(self, DesiredWeightsAndCapacities: List[DesiredWeightAndCapacity], EndpointName: str) -> UpdateEndpointWeightsAndCapacitiesOutput:
        pass

    def update_notebook_instance(self, NotebookInstanceName: str, InstanceType: str=None, RoleArn: str=None, LifecycleConfigName: str=None, DisassociateLifecycleConfig: DisassociateNotebookInstanceLifecycleConfig=None, VolumeSizeInGB: int=None, DefaultCodeRepository: str=None, AdditionalCodeRepositories: List[CodeRepositoryNameOrUrl]=None, AcceleratorTypes: List[NotebookInstanceAcceleratorType]=None, DisassociateAcceleratorTypes: DisassociateNotebookInstanceAcceleratorTypes=None, DisassociateDefaultCodeRepository: DisassociateDefaultCodeRepository=None, DisassociateAdditionalCodeRepositories: DisassociateAdditionalCodeRepositories=None) -> UpdateNotebookInstanceOutput:
        pass

    def update_notebook_instance_lifecycle_config(self, NotebookInstanceLifecycleConfigName: str, OnCreate: List[NotebookInstanceLifecycleHook]=None, OnStart: List[NotebookInstanceLifecycleHook]=None) -> UpdateNotebookInstanceLifecycleConfigOutput:
        pass

    def update_workteam(self, WorkteamName: str, MemberDefinitions: List[MemberDefinition]=None, Description: str=None) -> UpdateWorkteamResponse:
        pass


class SageMakerRuntime(BaseClient):
    class InvokeEndpointInput(Mapping):
        pass

    class InvokeEndpointOutput(Mapping):
        pass

    class BodyBlob(object):
        pass

    def invoke_endpoint(self, Body: BodyBlob, EndpointName: str, ContentType: str=None, Accept: str=None, CustomAttributes: str=None) -> InvokeEndpointOutput:
        pass


class SimpleDB(BaseClient):
    class BatchDeleteAttributesRequest(Mapping):
        pass

    class DeletableItem(Mapping):
        pass

    class BatchPutAttributesRequest(Mapping):
        pass

    class ReplaceableItem(Mapping):
        pass

    class CreateDomainRequest(Mapping):
        pass

    class DeleteAttributesRequest(Mapping):
        pass

    class Attribute(Mapping):
        pass

    class UpdateCondition(Mapping):
        pass

    class DeleteDomainRequest(Mapping):
        pass

    class DomainMetadataRequest(Mapping):
        pass

    class DomainMetadataResult(Mapping):
        pass

    class GetAttributesRequest(Mapping):
        pass

    class GetAttributesResult(Mapping):
        pass

    class String(object):
        pass

    class Boolean(object):
        pass

    class ListDomainsRequest(Mapping):
        pass

    class ListDomainsResult(Mapping):
        pass

    class PutAttributesRequest(Mapping):
        pass

    class ReplaceableAttribute(Mapping):
        pass

    class SelectRequest(Mapping):
        pass

    class SelectResult(Mapping):
        pass

    def batch_delete_attributes(self, Items: List[DeletableItem], DomainName: str):
        pass

    def batch_put_attributes(self, Items: List[ReplaceableItem], DomainName: str):
        pass

    def create_domain(self, DomainName: str):
        pass

    def delete_attributes(self, ItemName: str, DomainName: str, Attributes: List[Attribute]=None, Expected: UpdateCondition=None):
        pass

    def delete_domain(self, DomainName: str):
        pass

    def domain_metadata(self, DomainName: str) -> DomainMetadataResult:
        pass

    def get_attributes(self, ItemName: str, DomainName: str, AttributeNames: List[String]=None, ConsistentRead: Boolean=None) -> GetAttributesResult:
        pass

    def list_domains(self, MaxNumberOfDomains: int=None, NextToken: str=None) -> ListDomainsResult:
        pass

    def put_attributes(self, Attributes: List[ReplaceableAttribute], ItemName: str, DomainName: str, Expected: UpdateCondition=None):
        pass

    def select(self, SelectExpression: str, NextToken: str=None, ConsistentRead: Boolean=None) -> SelectResult:
        pass


class SecretsManager(BaseClient):
    class CancelRotateSecretRequest(Mapping):
        pass

    class CancelRotateSecretResponse(Mapping):
        pass

    class CreateSecretRequest(Mapping):
        pass

    class CreateSecretResponse(Mapping):
        pass

    class SecretBinaryType(object):
        pass

    class Tag(Mapping):
        pass

    class DeleteResourcePolicyRequest(Mapping):
        pass

    class DeleteResourcePolicyResponse(Mapping):
        pass

    class DeleteSecretRequest(Mapping):
        pass

    class DeleteSecretResponse(Mapping):
        pass

    class RecoveryWindowInDaysType(object):
        pass

    class BooleanType(object):
        pass

    class DescribeSecretRequest(Mapping):
        pass

    class DescribeSecretResponse(Mapping):
        pass

    class GetRandomPasswordRequest(Mapping):
        pass

    class GetRandomPasswordResponse(Mapping):
        pass

    class PasswordLengthType(object):
        pass

    class ExcludeNumbersType(object):
        pass

    class ExcludePunctuationType(object):
        pass

    class ExcludeUppercaseType(object):
        pass

    class ExcludeLowercaseType(object):
        pass

    class IncludeSpaceType(object):
        pass

    class RequireEachIncludedTypeType(object):
        pass

    class GetResourcePolicyRequest(Mapping):
        pass

    class GetResourcePolicyResponse(Mapping):
        pass

    class GetSecretValueRequest(Mapping):
        pass

    class GetSecretValueResponse(Mapping):
        pass

    class ListSecretVersionIdsRequest(Mapping):
        pass

    class ListSecretVersionIdsResponse(Mapping):
        pass

    class ListSecretsRequest(Mapping):
        pass

    class ListSecretsResponse(Mapping):
        pass

    class PutResourcePolicyRequest(Mapping):
        pass

    class PutResourcePolicyResponse(Mapping):
        pass

    class PutSecretValueRequest(Mapping):
        pass

    class PutSecretValueResponse(Mapping):
        pass

    class SecretVersionStageType(object):
        pass

    class RestoreSecretRequest(Mapping):
        pass

    class RestoreSecretResponse(Mapping):
        pass

    class RotateSecretRequest(Mapping):
        pass

    class RotateSecretResponse(Mapping):
        pass

    class RotationRulesType(Mapping):
        pass

    class TagResourceRequest(Mapping):
        pass

    class UntagResourceRequest(Mapping):
        pass

    class TagKeyType(object):
        pass

    class UpdateSecretRequest(Mapping):
        pass

    class UpdateSecretResponse(Mapping):
        pass

    class UpdateSecretVersionStageRequest(Mapping):
        pass

    class UpdateSecretVersionStageResponse(Mapping):
        pass

    def cancel_rotate_secret(self, SecretId: str) -> CancelRotateSecretResponse:
        pass

    def create_secret(self, Name: str, ClientRequestToken: str=None, Description: str=None, KmsKeyId: str=None, SecretBinary: SecretBinaryType=None, SecretString: str=None, Tags: List[Tag]=None) -> CreateSecretResponse:
        pass

    def delete_resource_policy(self, SecretId: str) -> DeleteResourcePolicyResponse:
        pass

    def delete_secret(self, SecretId: str, RecoveryWindowInDays: RecoveryWindowInDaysType=None, ForceDeleteWithoutRecovery: BooleanType=None) -> DeleteSecretResponse:
        pass

    def describe_secret(self, SecretId: str) -> DescribeSecretResponse:
        pass

    def get_random_password(self, PasswordLength: PasswordLengthType=None, ExcludeCharacters: str=None, ExcludeNumbers: ExcludeNumbersType=None, ExcludePunctuation: ExcludePunctuationType=None, ExcludeUppercase: ExcludeUppercaseType=None, ExcludeLowercase: ExcludeLowercaseType=None, IncludeSpace: IncludeSpaceType=None, RequireEachIncludedType: RequireEachIncludedTypeType=None) -> GetRandomPasswordResponse:
        pass

    def get_resource_policy(self, SecretId: str) -> GetResourcePolicyResponse:
        pass

    def get_secret_value(self, SecretId: str, VersionId: str=None, VersionStage: str=None) -> GetSecretValueResponse:
        pass

    def list_secret_version_ids(self, SecretId: str, MaxResults: int=None, NextToken: str=None, IncludeDeprecated: BooleanType=None) -> ListSecretVersionIdsResponse:
        pass

    def list_secrets(self, MaxResults: int=None, NextToken: str=None) -> ListSecretsResponse:
        pass

    def put_resource_policy(self, ResourcePolicy: str, SecretId: str) -> PutResourcePolicyResponse:
        pass

    def put_secret_value(self, SecretId: str, ClientRequestToken: str=None, SecretBinary: SecretBinaryType=None, SecretString: str=None, VersionStages: List[SecretVersionStageType]=None) -> PutSecretValueResponse:
        pass

    def restore_secret(self, SecretId: str) -> RestoreSecretResponse:
        pass

    def rotate_secret(self, SecretId: str, ClientRequestToken: str=None, RotationLambdaARN: str=None, RotationRules: RotationRulesType=None) -> RotateSecretResponse:
        pass

    def tag_resource(self, Tags: List[Tag], SecretId: str):
        pass

    def untag_resource(self, TagKeys: List[TagKeyType], SecretId: str):
        pass

    def update_secret(self, SecretId: str, ClientRequestToken: str=None, Description: str=None, KmsKeyId: str=None, SecretBinary: SecretBinaryType=None, SecretString: str=None) -> UpdateSecretResponse:
        pass

    def update_secret_version_stage(self, VersionStage: str, SecretId: str, RemoveFromVersionId: str=None, MoveToVersionId: str=None) -> UpdateSecretVersionStageResponse:
        pass


class SecurityHub(BaseClient):
    class AcceptInvitationRequest(Mapping):
        pass

    class AcceptInvitationResponse(Mapping):
        pass

    class BatchDisableStandardsRequest(Mapping):
        pass

    class BatchDisableStandardsResponse(Mapping):
        pass

    class NonEmptyString(object):
        pass

    class BatchEnableStandardsRequest(Mapping):
        pass

    class BatchEnableStandardsResponse(Mapping):
        pass

    class StandardsSubscriptionRequest(Mapping):
        pass

    class BatchImportFindingsRequest(Mapping):
        pass

    class BatchImportFindingsResponse(Mapping):
        pass

    class AwsSecurityFinding(Mapping):
        pass

    class CreateInsightRequest(Mapping):
        pass

    class CreateInsightResponse(Mapping):
        pass

    class AwsSecurityFindingFilters(Mapping):
        pass

    class CreateMembersRequest(Mapping):
        pass

    class CreateMembersResponse(Mapping):
        pass

    class AccountDetails(Mapping):
        pass

    class DeclineInvitationsRequest(Mapping):
        pass

    class DeclineInvitationsResponse(Mapping):
        pass

    class DeleteInsightRequest(Mapping):
        pass

    class DeleteInsightResponse(Mapping):
        pass

    class DeleteInvitationsRequest(Mapping):
        pass

    class DeleteInvitationsResponse(Mapping):
        pass

    class DeleteMembersRequest(Mapping):
        pass

    class DeleteMembersResponse(Mapping):
        pass

    class DisableImportFindingsForProductRequest(Mapping):
        pass

    class DisableImportFindingsForProductResponse(Mapping):
        pass

    class DisableSecurityHubRequest(Mapping):
        pass

    class DisableSecurityHubResponse(Mapping):
        pass

    class DisassociateFromMasterAccountRequest(Mapping):
        pass

    class DisassociateFromMasterAccountResponse(Mapping):
        pass

    class DisassociateMembersRequest(Mapping):
        pass

    class DisassociateMembersResponse(Mapping):
        pass

    class EnableImportFindingsForProductRequest(Mapping):
        pass

    class EnableImportFindingsForProductResponse(Mapping):
        pass

    class EnableSecurityHubRequest(Mapping):
        pass

    class EnableSecurityHubResponse(Mapping):
        pass

    class GetEnabledStandardsRequest(Mapping):
        pass

    class GetEnabledStandardsResponse(Mapping):
        pass

    class GetFindingsRequest(Mapping):
        pass

    class GetFindingsResponse(Mapping):
        pass

    class SortCriterion(Mapping):
        pass

    class GetInsightResultsRequest(Mapping):
        pass

    class GetInsightResultsResponse(Mapping):
        pass

    class GetInsightsRequest(Mapping):
        pass

    class GetInsightsResponse(Mapping):
        pass

    class GetInvitationsCountRequest(Mapping):
        pass

    class GetInvitationsCountResponse(Mapping):
        pass

    class GetMasterAccountRequest(Mapping):
        pass

    class GetMasterAccountResponse(Mapping):
        pass

    class GetMembersRequest(Mapping):
        pass

    class GetMembersResponse(Mapping):
        pass

    class InviteMembersRequest(Mapping):
        pass

    class InviteMembersResponse(Mapping):
        pass

    class ListEnabledProductsForImportRequest(Mapping):
        pass

    class ListEnabledProductsForImportResponse(Mapping):
        pass

    class ListInvitationsRequest(Mapping):
        pass

    class ListInvitationsResponse(Mapping):
        pass

    class ListMembersRequest(Mapping):
        pass

    class ListMembersResponse(Mapping):
        pass

    class Boolean(object):
        pass

    class UpdateFindingsRequest(Mapping):
        pass

    class UpdateFindingsResponse(Mapping):
        pass

    class NoteUpdate(Mapping):
        pass

    class UpdateInsightRequest(Mapping):
        pass

    class UpdateInsightResponse(Mapping):
        pass

    def accept_invitation(self, MasterId: str=None, InvitationId: str=None) -> AcceptInvitationResponse:
        pass

    def batch_disable_standards(self, StandardsSubscriptionArns: List[NonEmptyString]) -> BatchDisableStandardsResponse:
        pass

    def batch_enable_standards(self, StandardsSubscriptionRequests: List[StandardsSubscriptionRequest]) -> BatchEnableStandardsResponse:
        pass

    def batch_import_findings(self, Findings: List[AwsSecurityFinding]) -> BatchImportFindingsResponse:
        pass

    def create_insight(self, GroupByAttribute: str, Filters: AwsSecurityFindingFilters, Name: str) -> CreateInsightResponse:
        pass

    def create_members(self, AccountDetails: List[AccountDetails]=None) -> CreateMembersResponse:
        pass

    def decline_invitations(self, AccountIds: List[NonEmptyString]=None) -> DeclineInvitationsResponse:
        pass

    def delete_insight(self, InsightArn: str) -> DeleteInsightResponse:
        pass

    def delete_invitations(self, AccountIds: List[NonEmptyString]=None) -> DeleteInvitationsResponse:
        pass

    def delete_members(self, AccountIds: List[NonEmptyString]=None) -> DeleteMembersResponse:
        pass

    def disable_import_findings_for_product(self, ProductSubscriptionArn: str) -> DisableImportFindingsForProductResponse:
        pass

    def disable_security_hub(self) -> DisableSecurityHubResponse:
        pass

    def disassociate_from_master_account(self) -> DisassociateFromMasterAccountResponse:
        pass

    def disassociate_members(self, AccountIds: List[NonEmptyString]=None) -> DisassociateMembersResponse:
        pass

    def enable_import_findings_for_product(self, ProductArn: str) -> EnableImportFindingsForProductResponse:
        pass

    def enable_security_hub(self) -> EnableSecurityHubResponse:
        pass

    def get_enabled_standards(self, StandardsSubscriptionArns: List[NonEmptyString]=None, NextToken: str=None, MaxResults: int=None) -> GetEnabledStandardsResponse:
        pass

    def get_findings(self, Filters: AwsSecurityFindingFilters=None, SortCriteria: List[SortCriterion]=None, NextToken: str=None, MaxResults: int=None) -> GetFindingsResponse:
        pass

    def get_insight_results(self, InsightArn: str) -> GetInsightResultsResponse:
        pass

    def get_insights(self, InsightArns: List[NonEmptyString]=None, NextToken: str=None, MaxResults: int=None) -> GetInsightsResponse:
        pass

    def get_invitations_count(self) -> GetInvitationsCountResponse:
        pass

    def get_master_account(self) -> GetMasterAccountResponse:
        pass

    def get_members(self, AccountIds: List[NonEmptyString]) -> GetMembersResponse:
        pass

    def invite_members(self, AccountIds: List[NonEmptyString]=None) -> InviteMembersResponse:
        pass

    def list_enabled_products_for_import(self, NextToken: str=None, MaxResults: int=None) -> ListEnabledProductsForImportResponse:
        pass

    def list_invitations(self, MaxResults: int=None, NextToken: str=None) -> ListInvitationsResponse:
        pass

    def list_members(self, OnlyAssociated: Boolean=None, MaxResults: int=None, NextToken: str=None) -> ListMembersResponse:
        pass

    def update_findings(self, Filters: AwsSecurityFindingFilters, Note: NoteUpdate=None, RecordState: str=None) -> UpdateFindingsResponse:
        pass

    def update_insight(self, InsightArn: str, Name: str=None, Filters: AwsSecurityFindingFilters=None, GroupByAttribute: str=None) -> UpdateInsightResponse:
        pass


class ServerlessApplicationRepository(BaseClient):
    class CreateApplicationRequest(Mapping):
        pass

    class CreateApplicationResponse(Mapping):
        pass

    class __string(object):
        pass

    class CreateApplicationVersionRequest(Mapping):
        pass

    class CreateApplicationVersionResponse(Mapping):
        pass

    class CreateCloudFormationChangeSetRequest(Mapping):
        pass

    class CreateCloudFormationChangeSetResponse(Mapping):
        pass

    class ParameterValue(Mapping):
        pass

    class RollbackConfiguration(Mapping):
        pass

    class Tag(Mapping):
        pass

    class CreateCloudFormationTemplateRequest(Mapping):
        pass

    class CreateCloudFormationTemplateResponse(Mapping):
        pass

    class DeleteApplicationRequest(Mapping):
        pass

    class GetApplicationRequest(Mapping):
        pass

    class GetApplicationResponse(Mapping):
        pass

    class GetApplicationPolicyRequest(Mapping):
        pass

    class GetApplicationPolicyResponse(Mapping):
        pass

    class GetCloudFormationTemplateRequest(Mapping):
        pass

    class GetCloudFormationTemplateResponse(Mapping):
        pass

    class ListApplicationDependenciesRequest(Mapping):
        pass

    class ListApplicationDependenciesResponse(Mapping):
        pass

    class ListApplicationVersionsRequest(Mapping):
        pass

    class ListApplicationVersionsResponse(Mapping):
        pass

    class ListApplicationsRequest(Mapping):
        pass

    class ListApplicationsResponse(Mapping):
        pass

    class PutApplicationPolicyRequest(Mapping):
        pass

    class PutApplicationPolicyResponse(Mapping):
        pass

    class ApplicationPolicyStatement(Mapping):
        pass

    class UpdateApplicationRequest(Mapping):
        pass

    class UpdateApplicationResponse(Mapping):
        pass

    def create_application(self, Name: str, Description: str, Author: str, HomePageUrl: str=None, Labels: List[__string]=None, LicenseBody: str=None, LicenseUrl: str=None, ReadmeBody: str=None, ReadmeUrl: str=None, SemanticVersion: str=None, SourceCodeUrl: str=None, SpdxLicenseId: str=None, TemplateBody: str=None, TemplateUrl: str=None) -> CreateApplicationResponse:
        pass

    def create_application_version(self, SemanticVersion: str, ApplicationId: str, SourceCodeUrl: str=None, TemplateBody: str=None, TemplateUrl: str=None) -> CreateApplicationVersionResponse:
        pass

    def create_cloud_formation_change_set(self, StackName: str, ApplicationId: str, Capabilities: List[__string]=None, ChangeSetName: str=None, ClientToken: str=None, Description: str=None, NotificationArns: List[__string]=None, ParameterOverrides: List[ParameterValue]=None, ResourceTypes: List[__string]=None, RollbackConfiguration: RollbackConfiguration=None, SemanticVersion: str=None, Tags: List[Tag]=None, TemplateId: str=None) -> CreateCloudFormationChangeSetResponse:
        pass

    def create_cloud_formation_template(self, ApplicationId: str, SemanticVersion: str=None) -> CreateCloudFormationTemplateResponse:
        pass

    def delete_application(self, ApplicationId: str):
        pass

    def get_application(self, ApplicationId: str, SemanticVersion: str=None) -> GetApplicationResponse:
        pass

    def get_application_policy(self, ApplicationId: str) -> GetApplicationPolicyResponse:
        pass

    def get_cloud_formation_template(self, TemplateId: str, ApplicationId: str) -> GetCloudFormationTemplateResponse:
        pass

    def list_application_dependencies(self, ApplicationId: str, MaxItems: int=None, NextToken: str=None, SemanticVersion: str=None) -> ListApplicationDependenciesResponse:
        pass

    def list_application_versions(self, ApplicationId: str, MaxItems: int=None, NextToken: str=None) -> ListApplicationVersionsResponse:
        pass

    def list_applications(self, MaxItems: int=None, NextToken: str=None) -> ListApplicationsResponse:
        pass

    def put_application_policy(self, Statements: List[ApplicationPolicyStatement], ApplicationId: str) -> PutApplicationPolicyResponse:
        pass

    def update_application(self, ApplicationId: str, Author: str=None, Description: str=None, HomePageUrl: str=None, Labels: List[__string]=None, ReadmeBody: str=None, ReadmeUrl: str=None) -> UpdateApplicationResponse:
        pass


class ServiceCatalog(BaseClient):
    class AcceptPortfolioShareInput(Mapping):
        pass

    class AcceptPortfolioShareOutput(Mapping):
        pass

    class AssociatePrincipalWithPortfolioInput(Mapping):
        pass

    class AssociatePrincipalWithPortfolioOutput(Mapping):
        pass

    class AssociateProductWithPortfolioInput(Mapping):
        pass

    class AssociateProductWithPortfolioOutput(Mapping):
        pass

    class AssociateServiceActionWithProvisioningArtifactInput(Mapping):
        pass

    class AssociateServiceActionWithProvisioningArtifactOutput(Mapping):
        pass

    class AssociateTagOptionWithResourceInput(Mapping):
        pass

    class AssociateTagOptionWithResourceOutput(Mapping):
        pass

    class BatchAssociateServiceActionWithProvisioningArtifactInput(Mapping):
        pass

    class BatchAssociateServiceActionWithProvisioningArtifactOutput(Mapping):
        pass

    class ServiceActionAssociation(Mapping):
        pass

    class BatchDisassociateServiceActionFromProvisioningArtifactInput(Mapping):
        pass

    class BatchDisassociateServiceActionFromProvisioningArtifactOutput(Mapping):
        pass

    class CopyProductInput(Mapping):
        pass

    class CopyProductOutput(Mapping):
        pass

    class SourceProvisioningArtifactPropertiesMap(object):
        pass

    class CopyOption(object):
        pass

    class CreateConstraintInput(Mapping):
        pass

    class CreateConstraintOutput(Mapping):
        pass

    class CreatePortfolioInput(Mapping):
        pass

    class CreatePortfolioOutput(Mapping):
        pass

    class Tag(Mapping):
        pass

    class CreatePortfolioShareInput(Mapping):
        pass

    class CreatePortfolioShareOutput(Mapping):
        pass

    class OrganizationNode(Mapping):
        pass

    class CreateProductInput(Mapping):
        pass

    class CreateProductOutput(Mapping):
        pass

    class ProvisioningArtifactProperties(Mapping):
        pass

    class CreateProvisionedProductPlanInput(Mapping):
        pass

    class CreateProvisionedProductPlanOutput(Mapping):
        pass

    class NotificationArn(object):
        pass

    class UpdateProvisioningParameter(Mapping):
        pass

    class CreateProvisioningArtifactInput(Mapping):
        pass

    class CreateProvisioningArtifactOutput(Mapping):
        pass

    class CreateServiceActionInput(Mapping):
        pass

    class CreateServiceActionOutput(Mapping):
        pass

    class ServiceActionDefinitionMap(object):
        pass

    class CreateTagOptionInput(Mapping):
        pass

    class CreateTagOptionOutput(Mapping):
        pass

    class DeleteConstraintInput(Mapping):
        pass

    class DeleteConstraintOutput(Mapping):
        pass

    class DeletePortfolioInput(Mapping):
        pass

    class DeletePortfolioOutput(Mapping):
        pass

    class DeletePortfolioShareInput(Mapping):
        pass

    class DeletePortfolioShareOutput(Mapping):
        pass

    class DeleteProductInput(Mapping):
        pass

    class DeleteProductOutput(Mapping):
        pass

    class DeleteProvisionedProductPlanInput(Mapping):
        pass

    class DeleteProvisionedProductPlanOutput(Mapping):
        pass

    class IgnoreErrors(object):
        pass

    class DeleteProvisioningArtifactInput(Mapping):
        pass

    class DeleteProvisioningArtifactOutput(Mapping):
        pass

    class DeleteServiceActionInput(Mapping):
        pass

    class DeleteServiceActionOutput(Mapping):
        pass

    class DeleteTagOptionInput(Mapping):
        pass

    class DeleteTagOptionOutput(Mapping):
        pass

    class DescribeConstraintInput(Mapping):
        pass

    class DescribeConstraintOutput(Mapping):
        pass

    class DescribeCopyProductStatusInput(Mapping):
        pass

    class DescribeCopyProductStatusOutput(Mapping):
        pass

    class DescribePortfolioInput(Mapping):
        pass

    class DescribePortfolioOutput(Mapping):
        pass

    class DescribePortfolioShareStatusInput(Mapping):
        pass

    class DescribePortfolioShareStatusOutput(Mapping):
        pass

    class DescribeProductInput(Mapping):
        pass

    class DescribeProductOutput(Mapping):
        pass

    class DescribeProductAsAdminInput(Mapping):
        pass

    class DescribeProductAsAdminOutput(Mapping):
        pass

    class DescribeProductViewInput(Mapping):
        pass

    class DescribeProductViewOutput(Mapping):
        pass

    class DescribeProvisionedProductInput(Mapping):
        pass

    class DescribeProvisionedProductOutput(Mapping):
        pass

    class DescribeProvisionedProductPlanInput(Mapping):
        pass

    class DescribeProvisionedProductPlanOutput(Mapping):
        pass

    class DescribeProvisioningArtifactInput(Mapping):
        pass

    class DescribeProvisioningArtifactOutput(Mapping):
        pass

    class Verbose(object):
        pass

    class DescribeProvisioningParametersInput(Mapping):
        pass

    class DescribeProvisioningParametersOutput(Mapping):
        pass

    class DescribeRecordInput(Mapping):
        pass

    class DescribeRecordOutput(Mapping):
        pass

    class DescribeServiceActionInput(Mapping):
        pass

    class DescribeServiceActionOutput(Mapping):
        pass

    class DescribeTagOptionInput(Mapping):
        pass

    class DescribeTagOptionOutput(Mapping):
        pass

    class DisableAWSOrganizationsAccessInput(Mapping):
        pass

    class DisableAWSOrganizationsAccessOutput(Mapping):
        pass

    class DisassociatePrincipalFromPortfolioInput(Mapping):
        pass

    class DisassociatePrincipalFromPortfolioOutput(Mapping):
        pass

    class DisassociateProductFromPortfolioInput(Mapping):
        pass

    class DisassociateProductFromPortfolioOutput(Mapping):
        pass

    class DisassociateServiceActionFromProvisioningArtifactInput(Mapping):
        pass

    class DisassociateServiceActionFromProvisioningArtifactOutput(Mapping):
        pass

    class DisassociateTagOptionFromResourceInput(Mapping):
        pass

    class DisassociateTagOptionFromResourceOutput(Mapping):
        pass

    class EnableAWSOrganizationsAccessInput(Mapping):
        pass

    class EnableAWSOrganizationsAccessOutput(Mapping):
        pass

    class ExecuteProvisionedProductPlanInput(Mapping):
        pass

    class ExecuteProvisionedProductPlanOutput(Mapping):
        pass

    class ExecuteProvisionedProductServiceActionInput(Mapping):
        pass

    class ExecuteProvisionedProductServiceActionOutput(Mapping):
        pass

    class GetAWSOrganizationsAccessStatusInput(Mapping):
        pass

    class GetAWSOrganizationsAccessStatusOutput(Mapping):
        pass

    class ListAcceptedPortfolioSharesInput(Mapping):
        pass

    class ListAcceptedPortfolioSharesOutput(Mapping):
        pass

    class ListConstraintsForPortfolioInput(Mapping):
        pass

    class ListConstraintsForPortfolioOutput(Mapping):
        pass

    class ListLaunchPathsInput(Mapping):
        pass

    class ListLaunchPathsOutput(Mapping):
        pass

    class ListOrganizationPortfolioAccessInput(Mapping):
        pass

    class ListOrganizationPortfolioAccessOutput(Mapping):
        pass

    class ListPortfolioAccessInput(Mapping):
        pass

    class ListPortfolioAccessOutput(Mapping):
        pass

    class ListPortfoliosInput(Mapping):
        pass

    class ListPortfoliosOutput(Mapping):
        pass

    class ListPortfoliosForProductInput(Mapping):
        pass

    class ListPortfoliosForProductOutput(Mapping):
        pass

    class ListPrincipalsForPortfolioInput(Mapping):
        pass

    class ListPrincipalsForPortfolioOutput(Mapping):
        pass

    class ListProvisionedProductPlansInput(Mapping):
        pass

    class ListProvisionedProductPlansOutput(Mapping):
        pass

    class AccessLevelFilter(Mapping):
        pass

    class ListProvisioningArtifactsInput(Mapping):
        pass

    class ListProvisioningArtifactsOutput(Mapping):
        pass

    class ListProvisioningArtifactsForServiceActionInput(Mapping):
        pass

    class ListProvisioningArtifactsForServiceActionOutput(Mapping):
        pass

    class ListRecordHistoryInput(Mapping):
        pass

    class ListRecordHistoryOutput(Mapping):
        pass

    class ListRecordHistorySearchFilter(Mapping):
        pass

    class ListResourcesForTagOptionInput(Mapping):
        pass

    class ListResourcesForTagOptionOutput(Mapping):
        pass

    class ListServiceActionsInput(Mapping):
        pass

    class ListServiceActionsOutput(Mapping):
        pass

    class ListServiceActionsForProvisioningArtifactInput(Mapping):
        pass

    class ListServiceActionsForProvisioningArtifactOutput(Mapping):
        pass

    class ListTagOptionsInput(Mapping):
        pass

    class ListTagOptionsOutput(Mapping):
        pass

    class ListTagOptionsFilters(Mapping):
        pass

    class ProvisionProductInput(Mapping):
        pass

    class ProvisionProductOutput(Mapping):
        pass

    class ProvisioningParameter(Mapping):
        pass

    class ProvisioningPreferences(Mapping):
        pass

    class RejectPortfolioShareInput(Mapping):
        pass

    class RejectPortfolioShareOutput(Mapping):
        pass

    class ScanProvisionedProductsInput(Mapping):
        pass

    class ScanProvisionedProductsOutput(Mapping):
        pass

    class SearchProductsInput(Mapping):
        pass

    class SearchProductsOutput(Mapping):
        pass

    class ProductViewFilters(object):
        pass

    class SearchProductsAsAdminInput(Mapping):
        pass

    class SearchProductsAsAdminOutput(Mapping):
        pass

    class SearchProvisionedProductsInput(Mapping):
        pass

    class SearchProvisionedProductsOutput(Mapping):
        pass

    class ProvisionedProductFilters(object):
        pass

    class TerminateProvisionedProductInput(Mapping):
        pass

    class TerminateProvisionedProductOutput(Mapping):
        pass

    class UpdateConstraintInput(Mapping):
        pass

    class UpdateConstraintOutput(Mapping):
        pass

    class UpdatePortfolioInput(Mapping):
        pass

    class UpdatePortfolioOutput(Mapping):
        pass

    class TagKey(object):
        pass

    class UpdateProductInput(Mapping):
        pass

    class UpdateProductOutput(Mapping):
        pass

    class UpdateProvisionedProductInput(Mapping):
        pass

    class UpdateProvisionedProductOutput(Mapping):
        pass

    class UpdateProvisioningPreferences(Mapping):
        pass

    class UpdateProvisioningArtifactInput(Mapping):
        pass

    class UpdateProvisioningArtifactOutput(Mapping):
        pass

    class ProvisioningArtifactActive(object):
        pass

    class UpdateServiceActionInput(Mapping):
        pass

    class UpdateServiceActionOutput(Mapping):
        pass

    class UpdateTagOptionInput(Mapping):
        pass

    class UpdateTagOptionOutput(Mapping):
        pass

    class TagOptionActive(object):
        pass

    def accept_portfolio_share(self, PortfolioId: str, AcceptLanguage: str=None, PortfolioShareType: str=None) -> AcceptPortfolioShareOutput:
        pass

    def associate_principal_with_portfolio(self, PrincipalType: str, PrincipalARN: str, PortfolioId: str, AcceptLanguage: str=None) -> AssociatePrincipalWithPortfolioOutput:
        pass

    def associate_product_with_portfolio(self, PortfolioId: str, ProductId: str, AcceptLanguage: str=None, SourcePortfolioId: str=None) -> AssociateProductWithPortfolioOutput:
        pass

    def associate_service_action_with_provisioning_artifact(self, ServiceActionId: str, ProvisioningArtifactId: str, ProductId: str, AcceptLanguage: str=None) -> AssociateServiceActionWithProvisioningArtifactOutput:
        pass

    def associate_tag_option_with_resource(self, TagOptionId: str, ResourceId: str) -> AssociateTagOptionWithResourceOutput:
        pass

    def batch_associate_service_action_with_provisioning_artifact(self, ServiceActionAssociations: List[ServiceActionAssociation], AcceptLanguage: str=None) -> BatchAssociateServiceActionWithProvisioningArtifactOutput:
        pass

    def batch_disassociate_service_action_from_provisioning_artifact(self, ServiceActionAssociations: List[ServiceActionAssociation], AcceptLanguage: str=None) -> BatchDisassociateServiceActionFromProvisioningArtifactOutput:
        pass

    def copy_product(self, IdempotencyToken: str, SourceProductArn: str, AcceptLanguage: str=None, TargetProductId: str=None, TargetProductName: str=None, SourceProvisioningArtifactIdentifiers: List[SourceProvisioningArtifactPropertiesMap]=None, CopyOptions: List[CopyOption]=None) -> CopyProductOutput:
        pass

    def create_constraint(self, IdempotencyToken: str, Type: str, Parameters: str, ProductId: str, PortfolioId: str, AcceptLanguage: str=None, Description: str=None) -> CreateConstraintOutput:
        pass

    def create_portfolio(self, IdempotencyToken: str, ProviderName: str, DisplayName: str, AcceptLanguage: str=None, Description: str=None, Tags: List[Tag]=None) -> CreatePortfolioOutput:
        pass

    def create_portfolio_share(self, PortfolioId: str, AcceptLanguage: str=None, AccountId: str=None, OrganizationNode: OrganizationNode=None) -> CreatePortfolioShareOutput:
        pass

    def create_product(self, IdempotencyToken: str, ProvisioningArtifactParameters: ProvisioningArtifactProperties, ProductType: str, Owner: str, Name: str, AcceptLanguage: str=None, Description: str=None, Distributor: str=None, SupportDescription: str=None, SupportEmail: str=None, SupportUrl: str=None, Tags: List[Tag]=None) -> CreateProductOutput:
        pass

    def create_provisioned_product_plan(self, IdempotencyToken: str, ProvisioningArtifactId: str, ProvisionedProductName: str, ProductId: str, PlanType: str, PlanName: str, AcceptLanguage: str=None, NotificationArns: List[NotificationArn]=None, PathId: str=None, ProvisioningParameters: List[UpdateProvisioningParameter]=None, Tags: List[Tag]=None) -> CreateProvisionedProductPlanOutput:
        pass

    def create_provisioning_artifact(self, IdempotencyToken: str, Parameters: ProvisioningArtifactProperties, ProductId: str, AcceptLanguage: str=None) -> CreateProvisioningArtifactOutput:
        pass

    def create_service_action(self, IdempotencyToken: str, Definition: ServiceActionDefinitionMap, DefinitionType: str, Name: str, Description: str=None, AcceptLanguage: str=None) -> CreateServiceActionOutput:
        pass

    def create_tag_option(self, Value: str, Key: str) -> CreateTagOptionOutput:
        pass

    def delete_constraint(self, Id: str, AcceptLanguage: str=None) -> DeleteConstraintOutput:
        pass

    def delete_portfolio(self, Id: str, AcceptLanguage: str=None) -> DeletePortfolioOutput:
        pass

    def delete_portfolio_share(self, PortfolioId: str, AcceptLanguage: str=None, AccountId: str=None, OrganizationNode: OrganizationNode=None) -> DeletePortfolioShareOutput:
        pass

    def delete_product(self, Id: str, AcceptLanguage: str=None) -> DeleteProductOutput:
        pass

    def delete_provisioned_product_plan(self, PlanId: str, AcceptLanguage: str=None, IgnoreErrors: IgnoreErrors=None) -> DeleteProvisionedProductPlanOutput:
        pass

    def delete_provisioning_artifact(self, ProvisioningArtifactId: str, ProductId: str, AcceptLanguage: str=None) -> DeleteProvisioningArtifactOutput:
        pass

    def delete_service_action(self, Id: str, AcceptLanguage: str=None) -> DeleteServiceActionOutput:
        pass

    def delete_tag_option(self, Id: str) -> DeleteTagOptionOutput:
        pass

    def describe_constraint(self, Id: str, AcceptLanguage: str=None) -> DescribeConstraintOutput:
        pass

    def describe_copy_product_status(self, CopyProductToken: str, AcceptLanguage: str=None) -> DescribeCopyProductStatusOutput:
        pass

    def describe_portfolio(self, Id: str, AcceptLanguage: str=None) -> DescribePortfolioOutput:
        pass

    def describe_portfolio_share_status(self, PortfolioShareToken: str) -> DescribePortfolioShareStatusOutput:
        pass

    def describe_product(self, Id: str, AcceptLanguage: str=None) -> DescribeProductOutput:
        pass

    def describe_product_as_admin(self, Id: str, AcceptLanguage: str=None) -> DescribeProductAsAdminOutput:
        pass

    def describe_product_view(self, Id: str, AcceptLanguage: str=None) -> DescribeProductViewOutput:
        pass

    def describe_provisioned_product(self, Id: str, AcceptLanguage: str=None) -> DescribeProvisionedProductOutput:
        pass

    def describe_provisioned_product_plan(self, PlanId: str, AcceptLanguage: str=None, PageSize: int=None, PageToken: str=None) -> DescribeProvisionedProductPlanOutput:
        pass

    def describe_provisioning_artifact(self, ProductId: str, ProvisioningArtifactId: str, AcceptLanguage: str=None, Verbose: Verbose=None) -> DescribeProvisioningArtifactOutput:
        pass

    def describe_provisioning_parameters(self, ProvisioningArtifactId: str, ProductId: str, AcceptLanguage: str=None, PathId: str=None) -> DescribeProvisioningParametersOutput:
        pass

    def describe_record(self, Id: str, AcceptLanguage: str=None, PageToken: str=None, PageSize: int=None) -> DescribeRecordOutput:
        pass

    def describe_service_action(self, Id: str, AcceptLanguage: str=None) -> DescribeServiceActionOutput:
        pass

    def describe_tag_option(self, Id: str) -> DescribeTagOptionOutput:
        pass

    def disable_aws_organizations_access(self) -> DisableAWSOrganizationsAccessOutput:
        pass

    def disassociate_principal_from_portfolio(self, PrincipalARN: str, PortfolioId: str, AcceptLanguage: str=None) -> DisassociatePrincipalFromPortfolioOutput:
        pass

    def disassociate_product_from_portfolio(self, PortfolioId: str, ProductId: str, AcceptLanguage: str=None) -> DisassociateProductFromPortfolioOutput:
        pass

    def disassociate_service_action_from_provisioning_artifact(self, ServiceActionId: str, ProvisioningArtifactId: str, ProductId: str, AcceptLanguage: str=None) -> DisassociateServiceActionFromProvisioningArtifactOutput:
        pass

    def disassociate_tag_option_from_resource(self, TagOptionId: str, ResourceId: str) -> DisassociateTagOptionFromResourceOutput:
        pass

    def enable_aws_organizations_access(self) -> EnableAWSOrganizationsAccessOutput:
        pass

    def execute_provisioned_product_plan(self, IdempotencyToken: str, PlanId: str, AcceptLanguage: str=None) -> ExecuteProvisionedProductPlanOutput:
        pass

    def execute_provisioned_product_service_action(self, ExecuteToken: str, ServiceActionId: str, ProvisionedProductId: str, AcceptLanguage: str=None) -> ExecuteProvisionedProductServiceActionOutput:
        pass

    def get_aws_organizations_access_status(self) -> GetAWSOrganizationsAccessStatusOutput:
        pass

    def list_accepted_portfolio_shares(self, AcceptLanguage: str=None, PageToken: str=None, PageSize: int=None, PortfolioShareType: str=None) -> ListAcceptedPortfolioSharesOutput:
        pass

    def list_constraints_for_portfolio(self, PortfolioId: str, AcceptLanguage: str=None, ProductId: str=None, PageSize: int=None, PageToken: str=None) -> ListConstraintsForPortfolioOutput:
        pass

    def list_launch_paths(self, ProductId: str, AcceptLanguage: str=None, PageSize: int=None, PageToken: str=None) -> ListLaunchPathsOutput:
        pass

    def list_organization_portfolio_access(self, OrganizationNodeType: str, PortfolioId: str, AcceptLanguage: str=None, PageToken: str=None, PageSize: int=None) -> ListOrganizationPortfolioAccessOutput:
        pass

    def list_portfolio_access(self, PortfolioId: str, AcceptLanguage: str=None) -> ListPortfolioAccessOutput:
        pass

    def list_portfolios(self, AcceptLanguage: str=None, PageToken: str=None, PageSize: int=None) -> ListPortfoliosOutput:
        pass

    def list_portfolios_for_product(self, ProductId: str, AcceptLanguage: str=None, PageToken: str=None, PageSize: int=None) -> ListPortfoliosForProductOutput:
        pass

    def list_principals_for_portfolio(self, PortfolioId: str, AcceptLanguage: str=None, PageSize: int=None, PageToken: str=None) -> ListPrincipalsForPortfolioOutput:
        pass

    def list_provisioned_product_plans(self, AcceptLanguage: str=None, ProvisionProductId: str=None, PageSize: int=None, PageToken: str=None, AccessLevelFilter: AccessLevelFilter=None) -> ListProvisionedProductPlansOutput:
        pass

    def list_provisioning_artifacts(self, ProductId: str, AcceptLanguage: str=None) -> ListProvisioningArtifactsOutput:
        pass

    def list_provisioning_artifacts_for_service_action(self, ServiceActionId: str, PageSize: int=None, PageToken: str=None, AcceptLanguage: str=None) -> ListProvisioningArtifactsForServiceActionOutput:
        pass

    def list_record_history(self, AcceptLanguage: str=None, AccessLevelFilter: AccessLevelFilter=None, SearchFilter: ListRecordHistorySearchFilter=None, PageSize: int=None, PageToken: str=None) -> ListRecordHistoryOutput:
        pass

    def list_resources_for_tag_option(self, TagOptionId: str, ResourceType: str=None, PageSize: int=None, PageToken: str=None) -> ListResourcesForTagOptionOutput:
        pass

    def list_service_actions(self, AcceptLanguage: str=None, PageSize: int=None, PageToken: str=None) -> ListServiceActionsOutput:
        pass

    def list_service_actions_for_provisioning_artifact(self, ProvisioningArtifactId: str, ProductId: str, PageSize: int=None, PageToken: str=None, AcceptLanguage: str=None) -> ListServiceActionsForProvisioningArtifactOutput:
        pass

    def list_tag_options(self, Filters: ListTagOptionsFilters=None, PageSize: int=None, PageToken: str=None) -> ListTagOptionsOutput:
        pass

    def provision_product(self, ProvisionToken: str, ProvisionedProductName: str, ProvisioningArtifactId: str, ProductId: str, AcceptLanguage: str=None, PathId: str=None, ProvisioningParameters: List[ProvisioningParameter]=None, ProvisioningPreferences: ProvisioningPreferences=None, Tags: List[Tag]=None, NotificationArns: List[NotificationArn]=None) -> ProvisionProductOutput:
        pass

    def reject_portfolio_share(self, PortfolioId: str, AcceptLanguage: str=None, PortfolioShareType: str=None) -> RejectPortfolioShareOutput:
        pass

    def scan_provisioned_products(self, AcceptLanguage: str=None, AccessLevelFilter: AccessLevelFilter=None, PageSize: int=None, PageToken: str=None) -> ScanProvisionedProductsOutput:
        pass

    def search_products(self, AcceptLanguage: str=None, Filters: ProductViewFilters=None, PageSize: int=None, SortBy: str=None, SortOrder: str=None, PageToken: str=None) -> SearchProductsOutput:
        pass

    def search_products_as_admin(self, AcceptLanguage: str=None, PortfolioId: str=None, Filters: ProductViewFilters=None, SortBy: str=None, SortOrder: str=None, PageToken: str=None, PageSize: int=None, ProductSource: str=None) -> SearchProductsAsAdminOutput:
        pass

    def search_provisioned_products(self, AcceptLanguage: str=None, AccessLevelFilter: AccessLevelFilter=None, Filters: ProvisionedProductFilters=None, SortBy: str=None, SortOrder: str=None, PageSize: int=None, PageToken: str=None) -> SearchProvisionedProductsOutput:
        pass

    def terminate_provisioned_product(self, TerminateToken: str, ProvisionedProductName: str=None, ProvisionedProductId: str=None, IgnoreErrors: IgnoreErrors=None, AcceptLanguage: str=None) -> TerminateProvisionedProductOutput:
        pass

    def update_constraint(self, Id: str, AcceptLanguage: str=None, Description: str=None) -> UpdateConstraintOutput:
        pass

    def update_portfolio(self, Id: str, AcceptLanguage: str=None, DisplayName: str=None, Description: str=None, ProviderName: str=None, AddTags: List[Tag]=None, RemoveTags: List[TagKey]=None) -> UpdatePortfolioOutput:
        pass

    def update_product(self, Id: str, AcceptLanguage: str=None, Name: str=None, Owner: str=None, Description: str=None, Distributor: str=None, SupportDescription: str=None, SupportEmail: str=None, SupportUrl: str=None, AddTags: List[Tag]=None, RemoveTags: List[TagKey]=None) -> UpdateProductOutput:
        pass

    def update_provisioned_product(self, UpdateToken: str, AcceptLanguage: str=None, ProvisionedProductName: str=None, ProvisionedProductId: str=None, ProductId: str=None, ProvisioningArtifactId: str=None, PathId: str=None, ProvisioningParameters: List[UpdateProvisioningParameter]=None, ProvisioningPreferences: UpdateProvisioningPreferences=None) -> UpdateProvisionedProductOutput:
        pass

    def update_provisioning_artifact(self, ProvisioningArtifactId: str, ProductId: str, AcceptLanguage: str=None, Name: str=None, Description: str=None, Active: ProvisioningArtifactActive=None) -> UpdateProvisioningArtifactOutput:
        pass

    def update_service_action(self, Id: str, Name: str=None, Definition: ServiceActionDefinitionMap=None, Description: str=None, AcceptLanguage: str=None) -> UpdateServiceActionOutput:
        pass

    def update_tag_option(self, Id: str, Value: str=None, Active: TagOptionActive=None) -> UpdateTagOptionOutput:
        pass


class ServiceDiscovery(BaseClient):
    class CreateHttpNamespaceRequest(Mapping):
        pass

    class CreateHttpNamespaceResponse(Mapping):
        pass

    class CreatePrivateDnsNamespaceRequest(Mapping):
        pass

    class CreatePrivateDnsNamespaceResponse(Mapping):
        pass

    class CreatePublicDnsNamespaceRequest(Mapping):
        pass

    class CreatePublicDnsNamespaceResponse(Mapping):
        pass

    class CreateServiceRequest(Mapping):
        pass

    class CreateServiceResponse(Mapping):
        pass

    class DnsConfig(Mapping):
        pass

    class HealthCheckConfig(Mapping):
        pass

    class HealthCheckCustomConfig(Mapping):
        pass

    class DeleteNamespaceRequest(Mapping):
        pass

    class DeleteNamespaceResponse(Mapping):
        pass

    class DeleteServiceRequest(Mapping):
        pass

    class DeleteServiceResponse(Mapping):
        pass

    class DeregisterInstanceRequest(Mapping):
        pass

    class DeregisterInstanceResponse(Mapping):
        pass

    class DiscoverInstancesRequest(Mapping):
        pass

    class DiscoverInstancesResponse(Mapping):
        pass

    class Attributes(object):
        pass

    class GetInstanceRequest(Mapping):
        pass

    class GetInstanceResponse(Mapping):
        pass

    class GetInstancesHealthStatusRequest(Mapping):
        pass

    class GetInstancesHealthStatusResponse(Mapping):
        pass

    class ResourceId(object):
        pass

    class GetNamespaceRequest(Mapping):
        pass

    class GetNamespaceResponse(Mapping):
        pass

    class GetOperationRequest(Mapping):
        pass

    class GetOperationResponse(Mapping):
        pass

    class GetServiceRequest(Mapping):
        pass

    class GetServiceResponse(Mapping):
        pass

    class ListInstancesRequest(Mapping):
        pass

    class ListInstancesResponse(Mapping):
        pass

    class ListNamespacesRequest(Mapping):
        pass

    class ListNamespacesResponse(Mapping):
        pass

    class NamespaceFilter(Mapping):
        pass

    class ListOperationsRequest(Mapping):
        pass

    class ListOperationsResponse(Mapping):
        pass

    class OperationFilter(Mapping):
        pass

    class ListServicesRequest(Mapping):
        pass

    class ListServicesResponse(Mapping):
        pass

    class ServiceFilter(Mapping):
        pass

    class RegisterInstanceRequest(Mapping):
        pass

    class RegisterInstanceResponse(Mapping):
        pass

    class UpdateInstanceCustomHealthStatusRequest(Mapping):
        pass

    class UpdateServiceRequest(Mapping):
        pass

    class UpdateServiceResponse(Mapping):
        pass

    class ServiceChange(Mapping):
        pass

    def create_http_namespace(self, Name: str, CreatorRequestId: str=None, Description: str=None) -> CreateHttpNamespaceResponse:
        pass

    def create_private_dns_namespace(self, Vpc: str, Name: str, CreatorRequestId: str=None, Description: str=None) -> CreatePrivateDnsNamespaceResponse:
        pass

    def create_public_dns_namespace(self, Name: str, CreatorRequestId: str=None, Description: str=None) -> CreatePublicDnsNamespaceResponse:
        pass

    def create_service(self, Name: str, NamespaceId: str=None, CreatorRequestId: str=None, Description: str=None, DnsConfig: DnsConfig=None, HealthCheckConfig: HealthCheckConfig=None, HealthCheckCustomConfig: HealthCheckCustomConfig=None) -> CreateServiceResponse:
        pass

    def delete_namespace(self, Id: str) -> DeleteNamespaceResponse:
        pass

    def delete_service(self, Id: str) -> DeleteServiceResponse:
        pass

    def deregister_instance(self, InstanceId: str, ServiceId: str) -> DeregisterInstanceResponse:
        pass

    def discover_instances(self, ServiceName: str, NamespaceName: str, MaxResults: int=None, QueryParameters: Attributes=None, HealthStatus: str=None) -> DiscoverInstancesResponse:
        pass

    def get_instance(self, InstanceId: str, ServiceId: str) -> GetInstanceResponse:
        pass

    def get_instances_health_status(self, ServiceId: str, Instances: List[ResourceId]=None, MaxResults: int=None, NextToken: str=None) -> GetInstancesHealthStatusResponse:
        pass

    def get_namespace(self, Id: str) -> GetNamespaceResponse:
        pass

    def get_operation(self, OperationId: str) -> GetOperationResponse:
        pass

    def get_service(self, Id: str) -> GetServiceResponse:
        pass

    def list_instances(self, ServiceId: str, NextToken: str=None, MaxResults: int=None) -> ListInstancesResponse:
        pass

    def list_namespaces(self, NextToken: str=None, MaxResults: int=None, Filters: List[NamespaceFilter]=None) -> ListNamespacesResponse:
        pass

    def list_operations(self, NextToken: str=None, MaxResults: int=None, Filters: List[OperationFilter]=None) -> ListOperationsResponse:
        pass

    def list_services(self, NextToken: str=None, MaxResults: int=None, Filters: List[ServiceFilter]=None) -> ListServicesResponse:
        pass

    def register_instance(self, Attributes: Attributes, InstanceId: str, ServiceId: str, CreatorRequestId: str=None) -> RegisterInstanceResponse:
        pass

    def update_instance_custom_health_status(self, Status: str, InstanceId: str, ServiceId: str):
        pass

    def update_service(self, Service: ServiceChange, Id: str) -> UpdateServiceResponse:
        pass


class SES(BaseClient):
    class CloneReceiptRuleSetRequest(Mapping):
        pass

    class CloneReceiptRuleSetResponse(Mapping):
        pass

    class CreateConfigurationSetRequest(Mapping):
        pass

    class CreateConfigurationSetResponse(Mapping):
        pass

    class ConfigurationSet(Mapping):
        pass

    class CreateConfigurationSetEventDestinationRequest(Mapping):
        pass

    class CreateConfigurationSetEventDestinationResponse(Mapping):
        pass

    class EventDestination(Mapping):
        pass

    class CreateConfigurationSetTrackingOptionsRequest(Mapping):
        pass

    class CreateConfigurationSetTrackingOptionsResponse(Mapping):
        pass

    class TrackingOptions(Mapping):
        pass

    class CreateCustomVerificationEmailTemplateRequest(Mapping):
        pass

    class CreateReceiptFilterRequest(Mapping):
        pass

    class CreateReceiptFilterResponse(Mapping):
        pass

    class ReceiptFilter(Mapping):
        pass

    class CreateReceiptRuleRequest(Mapping):
        pass

    class CreateReceiptRuleResponse(Mapping):
        pass

    class ReceiptRule(Mapping):
        pass

    class CreateReceiptRuleSetRequest(Mapping):
        pass

    class CreateReceiptRuleSetResponse(Mapping):
        pass

    class CreateTemplateRequest(Mapping):
        pass

    class CreateTemplateResponse(Mapping):
        pass

    class Template(Mapping):
        pass

    class DeleteConfigurationSetRequest(Mapping):
        pass

    class DeleteConfigurationSetResponse(Mapping):
        pass

    class DeleteConfigurationSetEventDestinationRequest(Mapping):
        pass

    class DeleteConfigurationSetEventDestinationResponse(Mapping):
        pass

    class DeleteConfigurationSetTrackingOptionsRequest(Mapping):
        pass

    class DeleteConfigurationSetTrackingOptionsResponse(Mapping):
        pass

    class DeleteCustomVerificationEmailTemplateRequest(Mapping):
        pass

    class DeleteIdentityRequest(Mapping):
        pass

    class DeleteIdentityResponse(Mapping):
        pass

    class DeleteIdentityPolicyRequest(Mapping):
        pass

    class DeleteIdentityPolicyResponse(Mapping):
        pass

    class DeleteReceiptFilterRequest(Mapping):
        pass

    class DeleteReceiptFilterResponse(Mapping):
        pass

    class DeleteReceiptRuleRequest(Mapping):
        pass

    class DeleteReceiptRuleResponse(Mapping):
        pass

    class DeleteReceiptRuleSetRequest(Mapping):
        pass

    class DeleteReceiptRuleSetResponse(Mapping):
        pass

    class DeleteTemplateRequest(Mapping):
        pass

    class DeleteTemplateResponse(Mapping):
        pass

    class DeleteVerifiedEmailAddressRequest(Mapping):
        pass

    class DescribeActiveReceiptRuleSetRequest(Mapping):
        pass

    class DescribeActiveReceiptRuleSetResponse(Mapping):
        pass

    class DescribeConfigurationSetRequest(Mapping):
        pass

    class DescribeConfigurationSetResponse(Mapping):
        pass

    class ConfigurationSetAttribute(object):
        pass

    class DescribeReceiptRuleRequest(Mapping):
        pass

    class DescribeReceiptRuleResponse(Mapping):
        pass

    class DescribeReceiptRuleSetRequest(Mapping):
        pass

    class DescribeReceiptRuleSetResponse(Mapping):
        pass

    class GetAccountSendingEnabledResponse(Mapping):
        pass

    class GetCustomVerificationEmailTemplateRequest(Mapping):
        pass

    class GetCustomVerificationEmailTemplateResponse(Mapping):
        pass

    class GetIdentityDkimAttributesRequest(Mapping):
        pass

    class GetIdentityDkimAttributesResponse(Mapping):
        pass

    class Identity(object):
        pass

    class GetIdentityMailFromDomainAttributesRequest(Mapping):
        pass

    class GetIdentityMailFromDomainAttributesResponse(Mapping):
        pass

    class GetIdentityNotificationAttributesRequest(Mapping):
        pass

    class GetIdentityNotificationAttributesResponse(Mapping):
        pass

    class GetIdentityPoliciesRequest(Mapping):
        pass

    class GetIdentityPoliciesResponse(Mapping):
        pass

    class PolicyName(object):
        pass

    class GetIdentityVerificationAttributesRequest(Mapping):
        pass

    class GetIdentityVerificationAttributesResponse(Mapping):
        pass

    class GetSendQuotaResponse(Mapping):
        pass

    class GetSendStatisticsResponse(Mapping):
        pass

    class GetTemplateRequest(Mapping):
        pass

    class GetTemplateResponse(Mapping):
        pass

    class ListConfigurationSetsRequest(Mapping):
        pass

    class ListConfigurationSetsResponse(Mapping):
        pass

    class ListCustomVerificationEmailTemplatesRequest(Mapping):
        pass

    class ListCustomVerificationEmailTemplatesResponse(Mapping):
        pass

    class ListIdentitiesRequest(Mapping):
        pass

    class ListIdentitiesResponse(Mapping):
        pass

    class ListIdentityPoliciesRequest(Mapping):
        pass

    class ListIdentityPoliciesResponse(Mapping):
        pass

    class ListReceiptFiltersRequest(Mapping):
        pass

    class ListReceiptFiltersResponse(Mapping):
        pass

    class ListReceiptRuleSetsRequest(Mapping):
        pass

    class ListReceiptRuleSetsResponse(Mapping):
        pass

    class ListTemplatesRequest(Mapping):
        pass

    class ListTemplatesResponse(Mapping):
        pass

    class ListVerifiedEmailAddressesResponse(Mapping):
        pass

    class PutIdentityPolicyRequest(Mapping):
        pass

    class PutIdentityPolicyResponse(Mapping):
        pass

    class ReorderReceiptRuleSetRequest(Mapping):
        pass

    class ReorderReceiptRuleSetResponse(Mapping):
        pass

    class ReceiptRuleName(object):
        pass

    class SendBounceRequest(Mapping):
        pass

    class SendBounceResponse(Mapping):
        pass

    class MessageDsn(Mapping):
        pass

    class BouncedRecipientInfo(Mapping):
        pass

    class SendBulkTemplatedEmailRequest(Mapping):
        pass

    class SendBulkTemplatedEmailResponse(Mapping):
        pass

    class Address(object):
        pass

    class MessageTag(Mapping):
        pass

    class BulkEmailDestination(Mapping):
        pass

    class SendCustomVerificationEmailRequest(Mapping):
        pass

    class SendCustomVerificationEmailResponse(Mapping):
        pass

    class SendEmailRequest(Mapping):
        pass

    class SendEmailResponse(Mapping):
        pass

    class Destination(Mapping):
        pass

    class Message(Mapping):
        pass

    class SendRawEmailRequest(Mapping):
        pass

    class SendRawEmailResponse(Mapping):
        pass

    class RawMessage(Mapping):
        pass

    class SendTemplatedEmailRequest(Mapping):
        pass

    class SendTemplatedEmailResponse(Mapping):
        pass

    class SetActiveReceiptRuleSetRequest(Mapping):
        pass

    class SetActiveReceiptRuleSetResponse(Mapping):
        pass

    class SetIdentityDkimEnabledRequest(Mapping):
        pass

    class SetIdentityDkimEnabledResponse(Mapping):
        pass

    class Enabled(object):
        pass

    class SetIdentityFeedbackForwardingEnabledRequest(Mapping):
        pass

    class SetIdentityFeedbackForwardingEnabledResponse(Mapping):
        pass

    class SetIdentityHeadersInNotificationsEnabledRequest(Mapping):
        pass

    class SetIdentityHeadersInNotificationsEnabledResponse(Mapping):
        pass

    class SetIdentityMailFromDomainRequest(Mapping):
        pass

    class SetIdentityMailFromDomainResponse(Mapping):
        pass

    class SetIdentityNotificationTopicRequest(Mapping):
        pass

    class SetIdentityNotificationTopicResponse(Mapping):
        pass

    class SetReceiptRulePositionRequest(Mapping):
        pass

    class SetReceiptRulePositionResponse(Mapping):
        pass

    class TestRenderTemplateRequest(Mapping):
        pass

    class TestRenderTemplateResponse(Mapping):
        pass

    class UpdateAccountSendingEnabledRequest(Mapping):
        pass

    class UpdateConfigurationSetEventDestinationRequest(Mapping):
        pass

    class UpdateConfigurationSetEventDestinationResponse(Mapping):
        pass

    class UpdateConfigurationSetReputationMetricsEnabledRequest(Mapping):
        pass

    class UpdateConfigurationSetSendingEnabledRequest(Mapping):
        pass

    class UpdateConfigurationSetTrackingOptionsRequest(Mapping):
        pass

    class UpdateConfigurationSetTrackingOptionsResponse(Mapping):
        pass

    class UpdateCustomVerificationEmailTemplateRequest(Mapping):
        pass

    class UpdateReceiptRuleRequest(Mapping):
        pass

    class UpdateReceiptRuleResponse(Mapping):
        pass

    class UpdateTemplateRequest(Mapping):
        pass

    class UpdateTemplateResponse(Mapping):
        pass

    class VerifyDomainDkimRequest(Mapping):
        pass

    class VerifyDomainDkimResponse(Mapping):
        pass

    class VerifyDomainIdentityRequest(Mapping):
        pass

    class VerifyDomainIdentityResponse(Mapping):
        pass

    class VerifyEmailAddressRequest(Mapping):
        pass

    class VerifyEmailIdentityRequest(Mapping):
        pass

    class VerifyEmailIdentityResponse(Mapping):
        pass

    def clone_receipt_rule_set(self, OriginalRuleSetName: str, RuleSetName: str) -> CloneReceiptRuleSetResponse:
        pass

    def create_configuration_set(self, ConfigurationSet: ConfigurationSet) -> CreateConfigurationSetResponse:
        pass

    def create_configuration_set_event_destination(self, EventDestination: EventDestination, ConfigurationSetName: str) -> CreateConfigurationSetEventDestinationResponse:
        pass

    def create_configuration_set_tracking_options(self, TrackingOptions: TrackingOptions, ConfigurationSetName: str) -> CreateConfigurationSetTrackingOptionsResponse:
        pass

    def create_custom_verification_email_template(self, FailureRedirectionURL: str, SuccessRedirectionURL: str, TemplateContent: str, TemplateSubject: str, FromEmailAddress: str, TemplateName: str):
        pass

    def create_receipt_filter(self, Filter: ReceiptFilter) -> CreateReceiptFilterResponse:
        pass

    def create_receipt_rule(self, Rule: ReceiptRule, RuleSetName: str, After: str=None) -> CreateReceiptRuleResponse:
        pass

    def create_receipt_rule_set(self, RuleSetName: str) -> CreateReceiptRuleSetResponse:
        pass

    def create_template(self, Template: Template) -> CreateTemplateResponse:
        pass

    def delete_configuration_set(self, ConfigurationSetName: str) -> DeleteConfigurationSetResponse:
        pass

    def delete_configuration_set_event_destination(self, EventDestinationName: str, ConfigurationSetName: str) -> DeleteConfigurationSetEventDestinationResponse:
        pass

    def delete_configuration_set_tracking_options(self, ConfigurationSetName: str) -> DeleteConfigurationSetTrackingOptionsResponse:
        pass

    def delete_custom_verification_email_template(self, TemplateName: str):
        pass

    def delete_identity(self, Identity: str) -> DeleteIdentityResponse:
        pass

    def delete_identity_policy(self, PolicyName: str, Identity: str) -> DeleteIdentityPolicyResponse:
        pass

    def delete_receipt_filter(self, FilterName: str) -> DeleteReceiptFilterResponse:
        pass

    def delete_receipt_rule(self, RuleName: str, RuleSetName: str) -> DeleteReceiptRuleResponse:
        pass

    def delete_receipt_rule_set(self, RuleSetName: str) -> DeleteReceiptRuleSetResponse:
        pass

    def delete_template(self, TemplateName: str) -> DeleteTemplateResponse:
        pass

    def delete_verified_email_address(self, EmailAddress: str):
        pass

    def describe_active_receipt_rule_set(self) -> DescribeActiveReceiptRuleSetResponse:
        pass

    def describe_configuration_set(self, ConfigurationSetName: str, ConfigurationSetAttributeNames: List[ConfigurationSetAttribute]=None) -> DescribeConfigurationSetResponse:
        pass

    def describe_receipt_rule(self, RuleName: str, RuleSetName: str) -> DescribeReceiptRuleResponse:
        pass

    def describe_receipt_rule_set(self, RuleSetName: str) -> DescribeReceiptRuleSetResponse:
        pass

    def get_account_sending_enabled(self) -> GetAccountSendingEnabledResponse:
        pass

    def get_custom_verification_email_template(self, TemplateName: str) -> GetCustomVerificationEmailTemplateResponse:
        pass

    def get_identity_dkim_attributes(self, Identities: List[Identity]) -> GetIdentityDkimAttributesResponse:
        pass

    def get_identity_mail_from_domain_attributes(self, Identities: List[Identity]) -> GetIdentityMailFromDomainAttributesResponse:
        pass

    def get_identity_notification_attributes(self, Identities: List[Identity]) -> GetIdentityNotificationAttributesResponse:
        pass

    def get_identity_policies(self, PolicyNames: List[PolicyName], Identity: str) -> GetIdentityPoliciesResponse:
        pass

    def get_identity_verification_attributes(self, Identities: List[Identity]) -> GetIdentityVerificationAttributesResponse:
        pass

    def get_send_quota(self) -> GetSendQuotaResponse:
        pass

    def get_send_statistics(self) -> GetSendStatisticsResponse:
        pass

    def get_template(self, TemplateName: str) -> GetTemplateResponse:
        pass

    def list_configuration_sets(self, NextToken: str=None, MaxItems: int=None) -> ListConfigurationSetsResponse:
        pass

    def list_custom_verification_email_templates(self, NextToken: str=None, MaxResults: int=None) -> ListCustomVerificationEmailTemplatesResponse:
        pass

    def list_identities(self, IdentityType: str=None, NextToken: str=None, MaxItems: int=None) -> ListIdentitiesResponse:
        pass

    def list_identity_policies(self, Identity: str) -> ListIdentityPoliciesResponse:
        pass

    def list_receipt_filters(self) -> ListReceiptFiltersResponse:
        pass

    def list_receipt_rule_sets(self, NextToken: str=None) -> ListReceiptRuleSetsResponse:
        pass

    def list_templates(self, NextToken: str=None, MaxItems: int=None) -> ListTemplatesResponse:
        pass

    def list_verified_email_addresses(self) -> ListVerifiedEmailAddressesResponse:
        pass

    def put_identity_policy(self, Policy: str, PolicyName: str, Identity: str) -> PutIdentityPolicyResponse:
        pass

    def reorder_receipt_rule_set(self, RuleNames: List[ReceiptRuleName], RuleSetName: str) -> ReorderReceiptRuleSetResponse:
        pass

    def send_bounce(self, BouncedRecipientInfoList: List[BouncedRecipientInfo], BounceSender: str, OriginalMessageId: str, Explanation: str=None, MessageDsn: MessageDsn=None, BounceSenderArn: str=None) -> SendBounceResponse:
        pass

    def send_bulk_templated_email(self, Destinations: List[BulkEmailDestination], Template: str, Source: str, SourceArn: str=None, ReplyToAddresses: List[Address]=None, ReturnPath: str=None, ReturnPathArn: str=None, ConfigurationSetName: str=None, DefaultTags: List[MessageTag]=None, TemplateArn: str=None, DefaultTemplateData: str=None) -> SendBulkTemplatedEmailResponse:
        pass

    def send_custom_verification_email(self, TemplateName: str, EmailAddress: str, ConfigurationSetName: str=None) -> SendCustomVerificationEmailResponse:
        pass

    def send_email(self, Message: Message, Destination: Destination, Source: str, ReplyToAddresses: List[Address]=None, ReturnPath: str=None, SourceArn: str=None, ReturnPathArn: str=None, Tags: List[MessageTag]=None, ConfigurationSetName: str=None) -> SendEmailResponse:
        pass

    def send_raw_email(self, RawMessage: RawMessage, Source: str=None, Destinations: List[Address]=None, FromArn: str=None, SourceArn: str=None, ReturnPathArn: str=None, Tags: List[MessageTag]=None, ConfigurationSetName: str=None) -> SendRawEmailResponse:
        pass

    def send_templated_email(self, TemplateData: str, Template: str, Destination: Destination, Source: str, ReplyToAddresses: List[Address]=None, ReturnPath: str=None, SourceArn: str=None, ReturnPathArn: str=None, Tags: List[MessageTag]=None, ConfigurationSetName: str=None, TemplateArn: str=None) -> SendTemplatedEmailResponse:
        pass

    def set_active_receipt_rule_set(self, RuleSetName: str=None) -> SetActiveReceiptRuleSetResponse:
        pass

    def set_identity_dkim_enabled(self, DkimEnabled: Enabled, Identity: str) -> SetIdentityDkimEnabledResponse:
        pass

    def set_identity_feedback_forwarding_enabled(self, ForwardingEnabled: Enabled, Identity: str) -> SetIdentityFeedbackForwardingEnabledResponse:
        pass

    def set_identity_headers_in_notifications_enabled(self, Enabled: Enabled, NotificationType: str, Identity: str) -> SetIdentityHeadersInNotificationsEnabledResponse:
        pass

    def set_identity_mail_from_domain(self, Identity: str, MailFromDomain: str=None, BehaviorOnMXFailure: str=None) -> SetIdentityMailFromDomainResponse:
        pass

    def set_identity_notification_topic(self, NotificationType: str, Identity: str, SnsTopic: str=None) -> SetIdentityNotificationTopicResponse:
        pass

    def set_receipt_rule_position(self, RuleName: str, RuleSetName: str, After: str=None) -> SetReceiptRulePositionResponse:
        pass

    def test_render_template(self, TemplateData: str, TemplateName: str) -> TestRenderTemplateResponse:
        pass

    def update_account_sending_enabled(self, Enabled: Enabled=None):
        pass

    def update_configuration_set_event_destination(self, EventDestination: EventDestination, ConfigurationSetName: str) -> UpdateConfigurationSetEventDestinationResponse:
        pass

    def update_configuration_set_reputation_metrics_enabled(self, Enabled: Enabled, ConfigurationSetName: str):
        pass

    def update_configuration_set_sending_enabled(self, Enabled: Enabled, ConfigurationSetName: str):
        pass

    def update_configuration_set_tracking_options(self, TrackingOptions: TrackingOptions, ConfigurationSetName: str) -> UpdateConfigurationSetTrackingOptionsResponse:
        pass

    def update_custom_verification_email_template(self, TemplateName: str, FromEmailAddress: str=None, TemplateSubject: str=None, TemplateContent: str=None, SuccessRedirectionURL: str=None, FailureRedirectionURL: str=None):
        pass

    def update_receipt_rule(self, Rule: ReceiptRule, RuleSetName: str) -> UpdateReceiptRuleResponse:
        pass

    def update_template(self, Template: Template) -> UpdateTemplateResponse:
        pass

    def verify_domain_dkim(self, Domain: str) -> VerifyDomainDkimResponse:
        pass

    def verify_domain_identity(self, Domain: str) -> VerifyDomainIdentityResponse:
        pass

    def verify_email_address(self, EmailAddress: str):
        pass

    def verify_email_identity(self, EmailAddress: str) -> VerifyEmailIdentityResponse:
        pass


class Shield(BaseClient):
    class AssociateDRTLogBucketRequest(Mapping):
        pass

    class AssociateDRTLogBucketResponse(Mapping):
        pass

    class AssociateDRTRoleRequest(Mapping):
        pass

    class AssociateDRTRoleResponse(Mapping):
        pass

    class CreateProtectionRequest(Mapping):
        pass

    class CreateProtectionResponse(Mapping):
        pass

    class CreateSubscriptionRequest(Mapping):
        pass

    class CreateSubscriptionResponse(Mapping):
        pass

    class DeleteProtectionRequest(Mapping):
        pass

    class DeleteProtectionResponse(Mapping):
        pass

    class DeleteSubscriptionRequest(Mapping):
        pass

    class DeleteSubscriptionResponse(Mapping):
        pass

    class DescribeAttackRequest(Mapping):
        pass

    class DescribeAttackResponse(Mapping):
        pass

    class DescribeDRTAccessRequest(Mapping):
        pass

    class DescribeDRTAccessResponse(Mapping):
        pass

    class DescribeEmergencyContactSettingsRequest(Mapping):
        pass

    class DescribeEmergencyContactSettingsResponse(Mapping):
        pass

    class DescribeProtectionRequest(Mapping):
        pass

    class DescribeProtectionResponse(Mapping):
        pass

    class DescribeSubscriptionRequest(Mapping):
        pass

    class DescribeSubscriptionResponse(Mapping):
        pass

    class DisassociateDRTLogBucketRequest(Mapping):
        pass

    class DisassociateDRTLogBucketResponse(Mapping):
        pass

    class DisassociateDRTRoleRequest(Mapping):
        pass

    class DisassociateDRTRoleResponse(Mapping):
        pass

    class GetSubscriptionStateRequest(Mapping):
        pass

    class GetSubscriptionStateResponse(Mapping):
        pass

    class ListAttacksRequest(Mapping):
        pass

    class ListAttacksResponse(Mapping):
        pass

    class ResourceArn(object):
        pass

    class TimeRange(Mapping):
        pass

    class ListProtectionsRequest(Mapping):
        pass

    class ListProtectionsResponse(Mapping):
        pass

    class UpdateEmergencyContactSettingsRequest(Mapping):
        pass

    class UpdateEmergencyContactSettingsResponse(Mapping):
        pass

    class EmergencyContact(Mapping):
        pass

    class UpdateSubscriptionRequest(Mapping):
        pass

    class UpdateSubscriptionResponse(Mapping):
        pass

    def associate_drt_log_bucket(self, LogBucket: str) -> AssociateDRTLogBucketResponse:
        pass

    def associate_drt_role(self, RoleArn: str) -> AssociateDRTRoleResponse:
        pass

    def create_protection(self, ResourceArn: str, Name: str) -> CreateProtectionResponse:
        pass

    def create_subscription(self) -> CreateSubscriptionResponse:
        pass

    def delete_protection(self, ProtectionId: str) -> DeleteProtectionResponse:
        pass

    def delete_subscription(self) -> DeleteSubscriptionResponse:
        pass

    def describe_attack(self, AttackId: str) -> DescribeAttackResponse:
        pass

    def describe_drt_access(self) -> DescribeDRTAccessResponse:
        pass

    def describe_emergency_contact_settings(self) -> DescribeEmergencyContactSettingsResponse:
        pass

    def describe_protection(self, ProtectionId: str=None, ResourceArn: str=None) -> DescribeProtectionResponse:
        pass

    def describe_subscription(self) -> DescribeSubscriptionResponse:
        pass

    def disassociate_drt_log_bucket(self, LogBucket: str) -> DisassociateDRTLogBucketResponse:
        pass

    def disassociate_drt_role(self) -> DisassociateDRTRoleResponse:
        pass

    def get_subscription_state(self) -> GetSubscriptionStateResponse:
        pass

    def list_attacks(self, ResourceArns: List[ResourceArn]=None, StartTime: TimeRange=None, EndTime: TimeRange=None, NextToken: str=None, MaxResults: int=None) -> ListAttacksResponse:
        pass

    def list_protections(self, NextToken: str=None, MaxResults: int=None) -> ListProtectionsResponse:
        pass

    def update_emergency_contact_settings(self, EmergencyContactList: List[EmergencyContact]=None) -> UpdateEmergencyContactSettingsResponse:
        pass

    def update_subscription(self, AutoRenew: str=None) -> UpdateSubscriptionResponse:
        pass


class signer(BaseClient):
    class CancelSigningProfileRequest(Mapping):
        pass

    class DescribeSigningJobRequest(Mapping):
        pass

    class DescribeSigningJobResponse(Mapping):
        pass

    class GetSigningPlatformRequest(Mapping):
        pass

    class GetSigningPlatformResponse(Mapping):
        pass

    class GetSigningProfileRequest(Mapping):
        pass

    class GetSigningProfileResponse(Mapping):
        pass

    class ListSigningJobsRequest(Mapping):
        pass

    class ListSigningJobsResponse(Mapping):
        pass

    class ListSigningPlatformsRequest(Mapping):
        pass

    class ListSigningPlatformsResponse(Mapping):
        pass

    class ListSigningProfilesRequest(Mapping):
        pass

    class ListSigningProfilesResponse(Mapping):
        pass

    class bool(object):
        pass

    class PutSigningProfileRequest(Mapping):
        pass

    class PutSigningProfileResponse(Mapping):
        pass

    class SigningMaterial(Mapping):
        pass

    class SigningPlatformOverrides(Mapping):
        pass

    class SigningParameters(object):
        pass

    class StartSigningJobRequest(Mapping):
        pass

    class StartSigningJobResponse(Mapping):
        pass

    class Source(Mapping):
        pass

    class Destination(Mapping):
        pass

    def cancel_signing_profile(self, profileName: str):
        pass

    def describe_signing_job(self, jobId: str) -> DescribeSigningJobResponse:
        pass

    def get_signing_platform(self, platformId: str) -> GetSigningPlatformResponse:
        pass

    def get_signing_profile(self, profileName: str) -> GetSigningProfileResponse:
        pass

    def list_signing_jobs(self, status: str=None, platformId: str=None, requestedBy: str=None, maxResults: int=None, nextToken: str=None) -> ListSigningJobsResponse:
        pass

    def list_signing_platforms(self, category: str=None, partner: str=None, target: str=None, maxResults: int=None, nextToken: str=None) -> ListSigningPlatformsResponse:
        pass

    def list_signing_profiles(self, includeCanceled: bool=None, maxResults: int=None, nextToken: str=None) -> ListSigningProfilesResponse:
        pass

    def put_signing_profile(self, platformId: str, signingMaterial: SigningMaterial, profileName: str, overrides: SigningPlatformOverrides=None, signingParameters: SigningParameters=None) -> PutSigningProfileResponse:
        pass

    def start_signing_job(self, clientRequestToken: str, destination: Destination, source: Source, profileName: str=None) -> StartSigningJobResponse:
        pass


class SMS(BaseClient):
    class CreateAppRequest(Mapping):
        pass

    class CreateAppResponse(Mapping):
        pass

    class ServerGroup(Mapping):
        pass

    class Tag(Mapping):
        pass

    class CreateReplicationJobRequest(Mapping):
        pass

    class CreateReplicationJobResponse(Mapping):
        pass

    class Timestamp(object):
        pass

    class RunOnce(object):
        pass

    class Encrypted(object):
        pass

    class DeleteAppRequest(Mapping):
        pass

    class DeleteAppResponse(Mapping):
        pass

    class ForceStopAppReplication(object):
        pass

    class ForceTerminateApp(object):
        pass

    class DeleteAppLaunchConfigurationRequest(Mapping):
        pass

    class DeleteAppLaunchConfigurationResponse(Mapping):
        pass

    class DeleteAppReplicationConfigurationRequest(Mapping):
        pass

    class DeleteAppReplicationConfigurationResponse(Mapping):
        pass

    class DeleteReplicationJobRequest(Mapping):
        pass

    class DeleteReplicationJobResponse(Mapping):
        pass

    class DeleteServerCatalogRequest(Mapping):
        pass

    class DeleteServerCatalogResponse(Mapping):
        pass

    class DisassociateConnectorRequest(Mapping):
        pass

    class DisassociateConnectorResponse(Mapping):
        pass

    class GenerateChangeSetRequest(Mapping):
        pass

    class GenerateChangeSetResponse(Mapping):
        pass

    class GenerateTemplateRequest(Mapping):
        pass

    class GenerateTemplateResponse(Mapping):
        pass

    class GetAppRequest(Mapping):
        pass

    class GetAppResponse(Mapping):
        pass

    class GetAppLaunchConfigurationRequest(Mapping):
        pass

    class GetAppLaunchConfigurationResponse(Mapping):
        pass

    class GetAppReplicationConfigurationRequest(Mapping):
        pass

    class GetAppReplicationConfigurationResponse(Mapping):
        pass

    class GetConnectorsRequest(Mapping):
        pass

    class GetConnectorsResponse(Mapping):
        pass

    class GetReplicationJobsRequest(Mapping):
        pass

    class GetReplicationJobsResponse(Mapping):
        pass

    class GetReplicationRunsRequest(Mapping):
        pass

    class GetReplicationRunsResponse(Mapping):
        pass

    class GetServersRequest(Mapping):
        pass

    class GetServersResponse(Mapping):
        pass

    class VmServerAddress(Mapping):
        pass

    class ImportServerCatalogRequest(Mapping):
        pass

    class ImportServerCatalogResponse(Mapping):
        pass

    class LaunchAppRequest(Mapping):
        pass

    class LaunchAppResponse(Mapping):
        pass

    class ListAppsRequest(Mapping):
        pass

    class ListAppsResponse(Mapping):
        pass

    class AppId(object):
        pass

    class PutAppLaunchConfigurationRequest(Mapping):
        pass

    class PutAppLaunchConfigurationResponse(Mapping):
        pass

    class ServerGroupLaunchConfiguration(Mapping):
        pass

    class PutAppReplicationConfigurationRequest(Mapping):
        pass

    class PutAppReplicationConfigurationResponse(Mapping):
        pass

    class ServerGroupReplicationConfiguration(Mapping):
        pass

    class StartAppReplicationRequest(Mapping):
        pass

    class StartAppReplicationResponse(Mapping):
        pass

    class StartOnDemandReplicationRunRequest(Mapping):
        pass

    class StartOnDemandReplicationRunResponse(Mapping):
        pass

    class StopAppReplicationRequest(Mapping):
        pass

    class StopAppReplicationResponse(Mapping):
        pass

    class TerminateAppRequest(Mapping):
        pass

    class TerminateAppResponse(Mapping):
        pass

    class UpdateAppRequest(Mapping):
        pass

    class UpdateAppResponse(Mapping):
        pass

    class UpdateReplicationJobRequest(Mapping):
        pass

    class UpdateReplicationJobResponse(Mapping):
        pass

    def create_app(self, name: str=None, description: str=None, roleName: str=None, clientToken: str=None, serverGroups: List[ServerGroup]=None, tags: List[Tag]=None) -> CreateAppResponse:
        pass

    def create_replication_job(self, seedReplicationTime: Timestamp, serverId: str, frequency: int=None, runOnce: RunOnce=None, licenseType: str=None, roleName: str=None, description: str=None, numberOfRecentAmisToKeep: int=None, encrypted: Encrypted=None, kmsKeyId: str=None) -> CreateReplicationJobResponse:
        pass

    def delete_app(self, appId: str=None, forceStopAppReplication: ForceStopAppReplication=None, forceTerminateApp: ForceTerminateApp=None) -> DeleteAppResponse:
        pass

    def delete_app_launch_configuration(self, appId: str=None) -> DeleteAppLaunchConfigurationResponse:
        pass

    def delete_app_replication_configuration(self, appId: str=None) -> DeleteAppReplicationConfigurationResponse:
        pass

    def delete_replication_job(self, replicationJobId: str) -> DeleteReplicationJobResponse:
        pass

    def delete_server_catalog(self) -> DeleteServerCatalogResponse:
        pass

    def disassociate_connector(self, connectorId: str) -> DisassociateConnectorResponse:
        pass

    def generate_change_set(self, appId: str=None, changesetFormat: str=None) -> GenerateChangeSetResponse:
        pass

    def generate_template(self, appId: str=None, templateFormat: str=None) -> GenerateTemplateResponse:
        pass

    def get_app(self, appId: str=None) -> GetAppResponse:
        pass

    def get_app_launch_configuration(self, appId: str=None) -> GetAppLaunchConfigurationResponse:
        pass

    def get_app_replication_configuration(self, appId: str=None) -> GetAppReplicationConfigurationResponse:
        pass

    def get_connectors(self, nextToken: str=None, maxResults: int=None) -> GetConnectorsResponse:
        pass

    def get_replication_jobs(self, replicationJobId: str=None, nextToken: str=None, maxResults: int=None) -> GetReplicationJobsResponse:
        pass

    def get_replication_runs(self, replicationJobId: str, nextToken: str=None, maxResults: int=None) -> GetReplicationRunsResponse:
        pass

    def get_servers(self, nextToken: str=None, maxResults: int=None, vmServerAddressList: List[VmServerAddress]=None) -> GetServersResponse:
        pass

    def import_server_catalog(self) -> ImportServerCatalogResponse:
        pass

    def launch_app(self, appId: str=None) -> LaunchAppResponse:
        pass

    def list_apps(self, appIds: List[AppId]=None, nextToken: str=None, maxResults: int=None) -> ListAppsResponse:
        pass

    def put_app_launch_configuration(self, appId: str=None, roleName: str=None, serverGroupLaunchConfigurations: List[ServerGroupLaunchConfiguration]=None) -> PutAppLaunchConfigurationResponse:
        pass

    def put_app_replication_configuration(self, appId: str=None, serverGroupReplicationConfigurations: List[ServerGroupReplicationConfiguration]=None) -> PutAppReplicationConfigurationResponse:
        pass

    def start_app_replication(self, appId: str=None) -> StartAppReplicationResponse:
        pass

    def start_on_demand_replication_run(self, replicationJobId: str, description: str=None) -> StartOnDemandReplicationRunResponse:
        pass

    def stop_app_replication(self, appId: str=None) -> StopAppReplicationResponse:
        pass

    def terminate_app(self, appId: str=None) -> TerminateAppResponse:
        pass

    def update_app(self, appId: str=None, name: str=None, description: str=None, roleName: str=None, serverGroups: List[ServerGroup]=None, tags: List[Tag]=None) -> UpdateAppResponse:
        pass

    def update_replication_job(self, replicationJobId: str, frequency: int=None, nextReplicationRunStartTime: Timestamp=None, licenseType: str=None, roleName: str=None, description: str=None, numberOfRecentAmisToKeep: int=None, encrypted: Encrypted=None, kmsKeyId: str=None) -> UpdateReplicationJobResponse:
        pass


class PinpointSMSVoice(BaseClient):
    class CreateConfigurationSetRequest(Mapping):
        pass

    class CreateConfigurationSetResponse(Mapping):
        pass

    class CreateConfigurationSetEventDestinationRequest(Mapping):
        pass

    class CreateConfigurationSetEventDestinationResponse(Mapping):
        pass

    class EventDestinationDefinition(Mapping):
        pass

    class DeleteConfigurationSetRequest(Mapping):
        pass

    class DeleteConfigurationSetResponse(Mapping):
        pass

    class DeleteConfigurationSetEventDestinationRequest(Mapping):
        pass

    class DeleteConfigurationSetEventDestinationResponse(Mapping):
        pass

    class GetConfigurationSetEventDestinationsRequest(Mapping):
        pass

    class GetConfigurationSetEventDestinationsResponse(Mapping):
        pass

    class ListConfigurationSetsRequest(Mapping):
        pass

    class ListConfigurationSetsResponse(Mapping):
        pass

    class SendVoiceMessageRequest(Mapping):
        pass

    class SendVoiceMessageResponse(Mapping):
        pass

    class VoiceMessageContent(Mapping):
        pass

    class UpdateConfigurationSetEventDestinationRequest(Mapping):
        pass

    class UpdateConfigurationSetEventDestinationResponse(Mapping):
        pass

    def create_configuration_set(self, ConfigurationSetName: str=None) -> CreateConfigurationSetResponse:
        pass

    def create_configuration_set_event_destination(self, ConfigurationSetName: str, EventDestination: EventDestinationDefinition=None, EventDestinationName: str=None) -> CreateConfigurationSetEventDestinationResponse:
        pass

    def delete_configuration_set(self, ConfigurationSetName: str) -> DeleteConfigurationSetResponse:
        pass

    def delete_configuration_set_event_destination(self, EventDestinationName: str, ConfigurationSetName: str) -> DeleteConfigurationSetEventDestinationResponse:
        pass

    def get_configuration_set_event_destinations(self, ConfigurationSetName: str) -> GetConfigurationSetEventDestinationsResponse:
        pass

    def list_configuration_sets(self, NextToken: str=None, PageSize: str=None) -> ListConfigurationSetsResponse:
        pass

    def send_voice_message(self, CallerId: str=None, ConfigurationSetName: str=None, Content: VoiceMessageContent=None, DestinationPhoneNumber: str=None, OriginationPhoneNumber: str=None) -> SendVoiceMessageResponse:
        pass

    def update_configuration_set_event_destination(self, EventDestinationName: str, ConfigurationSetName: str, EventDestination: EventDestinationDefinition=None) -> UpdateConfigurationSetEventDestinationResponse:
        pass


class Snowball(BaseClient):
    class CancelClusterRequest(Mapping):
        pass

    class CancelClusterResult(Mapping):
        pass

    class CancelJobRequest(Mapping):
        pass

    class CancelJobResult(Mapping):
        pass

    class CreateAddressRequest(Mapping):
        pass

    class CreateAddressResult(Mapping):
        pass

    class Address(Mapping):
        pass

    class CreateClusterRequest(Mapping):
        pass

    class CreateClusterResult(Mapping):
        pass

    class JobResource(Mapping):
        pass

    class Notification(Mapping):
        pass

    class CreateJobRequest(Mapping):
        pass

    class CreateJobResult(Mapping):
        pass

    class DescribeAddressRequest(Mapping):
        pass

    class DescribeAddressResult(Mapping):
        pass

    class DescribeAddressesRequest(Mapping):
        pass

    class DescribeAddressesResult(Mapping):
        pass

    class DescribeClusterRequest(Mapping):
        pass

    class DescribeClusterResult(Mapping):
        pass

    class DescribeJobRequest(Mapping):
        pass

    class DescribeJobResult(Mapping):
        pass

    class GetJobManifestRequest(Mapping):
        pass

    class GetJobManifestResult(Mapping):
        pass

    class GetJobUnlockCodeRequest(Mapping):
        pass

    class GetJobUnlockCodeResult(Mapping):
        pass

    class GetSnowballUsageRequest(Mapping):
        pass

    class GetSnowballUsageResult(Mapping):
        pass

    class ListClusterJobsRequest(Mapping):
        pass

    class ListClusterJobsResult(Mapping):
        pass

    class ListClustersRequest(Mapping):
        pass

    class ListClustersResult(Mapping):
        pass

    class ListCompatibleImagesRequest(Mapping):
        pass

    class ListCompatibleImagesResult(Mapping):
        pass

    class ListJobsRequest(Mapping):
        pass

    class ListJobsResult(Mapping):
        pass

    class UpdateClusterRequest(Mapping):
        pass

    class UpdateClusterResult(Mapping):
        pass

    class UpdateJobRequest(Mapping):
        pass

    class UpdateJobResult(Mapping):
        pass

    def cancel_cluster(self, ClusterId: str) -> CancelClusterResult:
        pass

    def cancel_job(self, JobId: str) -> CancelJobResult:
        pass

    def create_address(self, Address: Address) -> CreateAddressResult:
        pass

    def create_cluster(self, ShippingOption: str, RoleARN: str, AddressId: str, Resources: JobResource, JobType: str, Description: str=None, KmsKeyARN: str=None, SnowballType: str=None, Notification: Notification=None, ForwardingAddressId: str=None) -> CreateClusterResult:
        pass

    def create_job(self, JobType: str=None, Resources: JobResource=None, Description: str=None, AddressId: str=None, KmsKeyARN: str=None, RoleARN: str=None, SnowballCapacityPreference: str=None, ShippingOption: str=None, Notification: Notification=None, ClusterId: str=None, SnowballType: str=None, ForwardingAddressId: str=None) -> CreateJobResult:
        pass

    def describe_address(self, AddressId: str) -> DescribeAddressResult:
        pass

    def describe_addresses(self, MaxResults: int=None, NextToken: str=None) -> DescribeAddressesResult:
        pass

    def describe_cluster(self, ClusterId: str) -> DescribeClusterResult:
        pass

    def describe_job(self, JobId: str) -> DescribeJobResult:
        pass

    def get_job_manifest(self, JobId: str) -> GetJobManifestResult:
        pass

    def get_job_unlock_code(self, JobId: str) -> GetJobUnlockCodeResult:
        pass

    def get_snowball_usage(self) -> GetSnowballUsageResult:
        pass

    def list_cluster_jobs(self, ClusterId: str, MaxResults: int=None, NextToken: str=None) -> ListClusterJobsResult:
        pass

    def list_clusters(self, MaxResults: int=None, NextToken: str=None) -> ListClustersResult:
        pass

    def list_compatible_images(self, MaxResults: int=None, NextToken: str=None) -> ListCompatibleImagesResult:
        pass

    def list_jobs(self, MaxResults: int=None, NextToken: str=None) -> ListJobsResult:
        pass

    def update_cluster(self, ClusterId: str, RoleARN: str=None, Description: str=None, Resources: JobResource=None, AddressId: str=None, ShippingOption: str=None, Notification: Notification=None, ForwardingAddressId: str=None) -> UpdateClusterResult:
        pass

    def update_job(self, JobId: str, RoleARN: str=None, Notification: Notification=None, Resources: JobResource=None, AddressId: str=None, ShippingOption: str=None, Description: str=None, SnowballCapacityPreference: str=None, ForwardingAddressId: str=None) -> UpdateJobResult:
        pass


class SNS(BaseClient):
    class AddPermissionInput(Mapping):
        pass

    class delegate(object):
        pass

    class action(object):
        pass

    class CheckIfPhoneNumberIsOptedOutInput(Mapping):
        pass

    class CheckIfPhoneNumberIsOptedOutResponse(Mapping):
        pass

    class ConfirmSubscriptionInput(Mapping):
        pass

    class ConfirmSubscriptionResponse(Mapping):
        pass

    class CreatePlatformApplicationInput(Mapping):
        pass

    class CreatePlatformApplicationResponse(Mapping):
        pass

    class MapStringToString(object):
        pass

    class CreatePlatformEndpointInput(Mapping):
        pass

    class CreateEndpointResponse(Mapping):
        pass

    class CreateTopicInput(Mapping):
        pass

    class CreateTopicResponse(Mapping):
        pass

    class TopicAttributesMap(object):
        pass

    class DeleteEndpointInput(Mapping):
        pass

    class DeletePlatformApplicationInput(Mapping):
        pass

    class DeleteTopicInput(Mapping):
        pass

    class GetEndpointAttributesInput(Mapping):
        pass

    class GetEndpointAttributesResponse(Mapping):
        pass

    class GetPlatformApplicationAttributesInput(Mapping):
        pass

    class GetPlatformApplicationAttributesResponse(Mapping):
        pass

    class GetSMSAttributesInput(Mapping):
        pass

    class GetSMSAttributesResponse(Mapping):
        pass

    class String(object):
        pass

    class GetSubscriptionAttributesInput(Mapping):
        pass

    class GetSubscriptionAttributesResponse(Mapping):
        pass

    class GetTopicAttributesInput(Mapping):
        pass

    class GetTopicAttributesResponse(Mapping):
        pass

    class ListEndpointsByPlatformApplicationInput(Mapping):
        pass

    class ListEndpointsByPlatformApplicationResponse(Mapping):
        pass

    class ListPhoneNumbersOptedOutInput(Mapping):
        pass

    class ListPhoneNumbersOptedOutResponse(Mapping):
        pass

    class ListPlatformApplicationsInput(Mapping):
        pass

    class ListPlatformApplicationsResponse(Mapping):
        pass

    class ListSubscriptionsInput(Mapping):
        pass

    class ListSubscriptionsResponse(Mapping):
        pass

    class ListSubscriptionsByTopicInput(Mapping):
        pass

    class ListSubscriptionsByTopicResponse(Mapping):
        pass

    class ListTopicsInput(Mapping):
        pass

    class ListTopicsResponse(Mapping):
        pass

    class OptInPhoneNumberInput(Mapping):
        pass

    class OptInPhoneNumberResponse(Mapping):
        pass

    class PublishInput(Mapping):
        pass

    class PublishResponse(Mapping):
        pass

    class MessageAttributeMap(object):
        pass

    class RemovePermissionInput(Mapping):
        pass

    class SetEndpointAttributesInput(Mapping):
        pass

    class SetPlatformApplicationAttributesInput(Mapping):
        pass

    class SetSMSAttributesInput(Mapping):
        pass

    class SetSMSAttributesResponse(Mapping):
        pass

    class SetSubscriptionAttributesInput(Mapping):
        pass

    class SetTopicAttributesInput(Mapping):
        pass

    class SubscribeInput(Mapping):
        pass

    class SubscribeResponse(Mapping):
        pass

    class SubscriptionAttributesMap(object):
        pass

    class boolean(object):
        pass

    class UnsubscribeInput(Mapping):
        pass

    def add_permission(self, ActionName: List[action], AWSAccountId: List[delegate], Label: str, TopicArn: str):
        pass

    def check_if_phone_number_is_opted_out(self, phoneNumber: str) -> CheckIfPhoneNumberIsOptedOutResponse:
        pass

    def confirm_subscription(self, Token: str, TopicArn: str, AuthenticateOnUnsubscribe: str=None) -> ConfirmSubscriptionResponse:
        pass

    def create_platform_application(self, Attributes: MapStringToString, Platform: str, Name: str) -> CreatePlatformApplicationResponse:
        pass

    def create_platform_endpoint(self, Token: str, PlatformApplicationArn: str, CustomUserData: str=None, Attributes: MapStringToString=None) -> CreateEndpointResponse:
        pass

    def create_topic(self, Name: str, Attributes: TopicAttributesMap=None) -> CreateTopicResponse:
        pass

    def delete_endpoint(self, EndpointArn: str):
        pass

    def delete_platform_application(self, PlatformApplicationArn: str):
        pass

    def delete_topic(self, TopicArn: str):
        pass

    def get_endpoint_attributes(self, EndpointArn: str) -> GetEndpointAttributesResponse:
        pass

    def get_platform_application_attributes(self, PlatformApplicationArn: str) -> GetPlatformApplicationAttributesResponse:
        pass

    def get_sms_attributes(self, attributes: List[String]=None) -> GetSMSAttributesResponse:
        pass

    def get_subscription_attributes(self, SubscriptionArn: str) -> GetSubscriptionAttributesResponse:
        pass

    def get_topic_attributes(self, TopicArn: str) -> GetTopicAttributesResponse:
        pass

    def list_endpoints_by_platform_application(self, PlatformApplicationArn: str, NextToken: str=None) -> ListEndpointsByPlatformApplicationResponse:
        pass

    def list_phone_numbers_opted_out(self, nextToken: str=None) -> ListPhoneNumbersOptedOutResponse:
        pass

    def list_platform_applications(self, NextToken: str=None) -> ListPlatformApplicationsResponse:
        pass

    def list_subscriptions(self, NextToken: str=None) -> ListSubscriptionsResponse:
        pass

    def list_subscriptions_by_topic(self, TopicArn: str, NextToken: str=None) -> ListSubscriptionsByTopicResponse:
        pass

    def list_topics(self, NextToken: str=None) -> ListTopicsResponse:
        pass

    def opt_in_phone_number(self, phoneNumber: str) -> OptInPhoneNumberResponse:
        pass

    def publish(self, Message: str, TopicArn: str=None, TargetArn: str=None, PhoneNumber: str=None, Subject: str=None, MessageStructure: str=None, MessageAttributes: MessageAttributeMap=None) -> PublishResponse:
        pass

    def remove_permission(self, Label: str, TopicArn: str):
        pass

    def set_endpoint_attributes(self, Attributes: MapStringToString, EndpointArn: str):
        pass

    def set_platform_application_attributes(self, Attributes: MapStringToString, PlatformApplicationArn: str):
        pass

    def set_sms_attributes(self, attributes: MapStringToString) -> SetSMSAttributesResponse:
        pass

    def set_subscription_attributes(self, AttributeName: str, SubscriptionArn: str, AttributeValue: str=None):
        pass

    def set_topic_attributes(self, AttributeName: str, TopicArn: str, AttributeValue: str=None):
        pass

    def subscribe(self, Protocol: str, TopicArn: str, Endpoint: str=None, Attributes: SubscriptionAttributesMap=None, ReturnSubscriptionArn: boolean=None) -> SubscribeResponse:
        pass

    def unsubscribe(self, SubscriptionArn: str):
        pass


class SQS(BaseClient):
    class AddPermissionRequest(Mapping):
        pass

    class String(object):
        pass

    class ChangeMessageVisibilityRequest(Mapping):
        pass

    class ChangeMessageVisibilityBatchRequest(Mapping):
        pass

    class ChangeMessageVisibilityBatchResult(Mapping):
        pass

    class ChangeMessageVisibilityBatchRequestEntry(Mapping):
        pass

    class CreateQueueRequest(Mapping):
        pass

    class CreateQueueResult(Mapping):
        pass

    class QueueAttributeMap(object):
        pass

    class DeleteMessageRequest(Mapping):
        pass

    class DeleteMessageBatchRequest(Mapping):
        pass

    class DeleteMessageBatchResult(Mapping):
        pass

    class DeleteMessageBatchRequestEntry(Mapping):
        pass

    class DeleteQueueRequest(Mapping):
        pass

    class GetQueueAttributesRequest(Mapping):
        pass

    class GetQueueAttributesResult(Mapping):
        pass

    class QueueAttributeName(object):
        pass

    class GetQueueUrlRequest(Mapping):
        pass

    class GetQueueUrlResult(Mapping):
        pass

    class ListDeadLetterSourceQueuesRequest(Mapping):
        pass

    class ListDeadLetterSourceQueuesResult(Mapping):
        pass

    class ListQueueTagsRequest(Mapping):
        pass

    class ListQueueTagsResult(Mapping):
        pass

    class ListQueuesRequest(Mapping):
        pass

    class ListQueuesResult(Mapping):
        pass

    class PurgeQueueRequest(Mapping):
        pass

    class ReceiveMessageRequest(Mapping):
        pass

    class ReceiveMessageResult(Mapping):
        pass

    class MessageAttributeName(object):
        pass

    class RemovePermissionRequest(Mapping):
        pass

    class SendMessageRequest(Mapping):
        pass

    class SendMessageResult(Mapping):
        pass

    class MessageBodyAttributeMap(object):
        pass

    class SendMessageBatchRequest(Mapping):
        pass

    class SendMessageBatchResult(Mapping):
        pass

    class SendMessageBatchRequestEntry(Mapping):
        pass

    class SetQueueAttributesRequest(Mapping):
        pass

    class TagQueueRequest(Mapping):
        pass

    class TagMap(object):
        pass

    class UntagQueueRequest(Mapping):
        pass

    class TagKey(object):
        pass

    def add_permission(self, Actions: List[String], AWSAccountIds: List[String], Label: str, QueueUrl: str):
        pass

    def change_message_visibility(self, VisibilityTimeout: int, ReceiptHandle: str, QueueUrl: str):
        pass

    def change_message_visibility_batch(self, Entries: List[ChangeMessageVisibilityBatchRequestEntry], QueueUrl: str) -> ChangeMessageVisibilityBatchResult:
        pass

    def create_queue(self, QueueName: str, Attributes: QueueAttributeMap=None) -> CreateQueueResult:
        pass

    def delete_message(self, ReceiptHandle: str, QueueUrl: str):
        pass

    def delete_message_batch(self, Entries: List[DeleteMessageBatchRequestEntry], QueueUrl: str) -> DeleteMessageBatchResult:
        pass

    def delete_queue(self, QueueUrl: str):
        pass

    def get_queue_attributes(self, QueueUrl: str, AttributeNames: List[QueueAttributeName]=None) -> GetQueueAttributesResult:
        pass

    def get_queue_url(self, QueueName: str, QueueOwnerAWSAccountId: str=None) -> GetQueueUrlResult:
        pass

    def list_dead_letter_source_queues(self, QueueUrl: str) -> ListDeadLetterSourceQueuesResult:
        pass

    def list_queue_tags(self, QueueUrl: str) -> ListQueueTagsResult:
        pass

    def list_queues(self, QueueNamePrefix: str=None) -> ListQueuesResult:
        pass

    def purge_queue(self, QueueUrl: str):
        pass

    def receive_message(self, QueueUrl: str, AttributeNames: List[QueueAttributeName]=None, MessageAttributeNames: List[MessageAttributeName]=None, MaxNumberOfMessages: int=None, VisibilityTimeout: int=None, WaitTimeSeconds: int=None, ReceiveRequestAttemptId: str=None) -> ReceiveMessageResult:
        pass

    def remove_permission(self, Label: str, QueueUrl: str):
        pass

    def send_message(self, MessageBody: str, QueueUrl: str, DelaySeconds: int=None, MessageAttributes: MessageBodyAttributeMap=None, MessageDeduplicationId: str=None, MessageGroupId: str=None) -> SendMessageResult:
        pass

    def send_message_batch(self, Entries: List[SendMessageBatchRequestEntry], QueueUrl: str) -> SendMessageBatchResult:
        pass

    def set_queue_attributes(self, Attributes: QueueAttributeMap, QueueUrl: str):
        pass

    def tag_queue(self, Tags: TagMap, QueueUrl: str):
        pass

    def untag_queue(self, TagKeys: List[TagKey], QueueUrl: str):
        pass


class SSM(BaseClient):
    class AddTagsToResourceRequest(Mapping):
        pass

    class AddTagsToResourceResult(Mapping):
        pass

    class Tag(Mapping):
        pass

    class CancelCommandRequest(Mapping):
        pass

    class CancelCommandResult(Mapping):
        pass

    class InstanceId(object):
        pass

    class CancelMaintenanceWindowExecutionRequest(Mapping):
        pass

    class CancelMaintenanceWindowExecutionResult(Mapping):
        pass

    class CreateActivationRequest(Mapping):
        pass

    class CreateActivationResult(Mapping):
        pass

    class ExpirationDate(object):
        pass

    class CreateAssociationRequest(Mapping):
        pass

    class CreateAssociationResult(Mapping):
        pass

    class Parameters(object):
        pass

    class Target(Mapping):
        pass

    class InstanceAssociationOutputLocation(Mapping):
        pass

    class CreateAssociationBatchRequest(Mapping):
        pass

    class CreateAssociationBatchResult(Mapping):
        pass

    class CreateAssociationBatchRequestEntry(Mapping):
        pass

    class CreateDocumentRequest(Mapping):
        pass

    class CreateDocumentResult(Mapping):
        pass

    class AttachmentsSource(Mapping):
        pass

    class CreateMaintenanceWindowRequest(Mapping):
        pass

    class CreateMaintenanceWindowResult(Mapping):
        pass

    class MaintenanceWindowAllowUnassociatedTargets(object):
        pass

    class CreatePatchBaselineRequest(Mapping):
        pass

    class CreatePatchBaselineResult(Mapping):
        pass

    class PatchFilterGroup(Mapping):
        pass

    class PatchRuleGroup(Mapping):
        pass

    class PatchId(object):
        pass

    class Boolean(object):
        pass

    class PatchSource(Mapping):
        pass

    class CreateResourceDataSyncRequest(Mapping):
        pass

    class CreateResourceDataSyncResult(Mapping):
        pass

    class ResourceDataSyncS3Destination(Mapping):
        pass

    class DeleteActivationRequest(Mapping):
        pass

    class DeleteActivationResult(Mapping):
        pass

    class DeleteAssociationRequest(Mapping):
        pass

    class DeleteAssociationResult(Mapping):
        pass

    class DeleteDocumentRequest(Mapping):
        pass

    class DeleteDocumentResult(Mapping):
        pass

    class DeleteInventoryRequest(Mapping):
        pass

    class DeleteInventoryResult(Mapping):
        pass

    class DryRun(object):
        pass

    class DeleteMaintenanceWindowRequest(Mapping):
        pass

    class DeleteMaintenanceWindowResult(Mapping):
        pass

    class DeleteParameterRequest(Mapping):
        pass

    class DeleteParameterResult(Mapping):
        pass

    class DeleteParametersRequest(Mapping):
        pass

    class DeleteParametersResult(Mapping):
        pass

    class PSParameterName(object):
        pass

    class DeletePatchBaselineRequest(Mapping):
        pass

    class DeletePatchBaselineResult(Mapping):
        pass

    class DeleteResourceDataSyncRequest(Mapping):
        pass

    class DeleteResourceDataSyncResult(Mapping):
        pass

    class DeregisterManagedInstanceRequest(Mapping):
        pass

    class DeregisterManagedInstanceResult(Mapping):
        pass

    class DeregisterPatchBaselineForPatchGroupRequest(Mapping):
        pass

    class DeregisterPatchBaselineForPatchGroupResult(Mapping):
        pass

    class DeregisterTargetFromMaintenanceWindowRequest(Mapping):
        pass

    class DeregisterTargetFromMaintenanceWindowResult(Mapping):
        pass

    class DeregisterTaskFromMaintenanceWindowRequest(Mapping):
        pass

    class DeregisterTaskFromMaintenanceWindowResult(Mapping):
        pass

    class DescribeActivationsRequest(Mapping):
        pass

    class DescribeActivationsResult(Mapping):
        pass

    class DescribeActivationsFilter(Mapping):
        pass

    class DescribeAssociationRequest(Mapping):
        pass

    class DescribeAssociationResult(Mapping):
        pass

    class DescribeAssociationExecutionTargetsRequest(Mapping):
        pass

    class DescribeAssociationExecutionTargetsResult(Mapping):
        pass

    class AssociationExecutionTargetsFilter(Mapping):
        pass

    class DescribeAssociationExecutionsRequest(Mapping):
        pass

    class DescribeAssociationExecutionsResult(Mapping):
        pass

    class AssociationExecutionFilter(Mapping):
        pass

    class DescribeAutomationExecutionsRequest(Mapping):
        pass

    class DescribeAutomationExecutionsResult(Mapping):
        pass

    class AutomationExecutionFilter(Mapping):
        pass

    class DescribeAutomationStepExecutionsRequest(Mapping):
        pass

    class DescribeAutomationStepExecutionsResult(Mapping):
        pass

    class StepExecutionFilter(Mapping):
        pass

    class DescribeAvailablePatchesRequest(Mapping):
        pass

    class DescribeAvailablePatchesResult(Mapping):
        pass

    class PatchOrchestratorFilter(Mapping):
        pass

    class DescribeDocumentRequest(Mapping):
        pass

    class DescribeDocumentResult(Mapping):
        pass

    class DescribeDocumentPermissionRequest(Mapping):
        pass

    class DescribeDocumentPermissionResponse(Mapping):
        pass

    class DescribeEffectiveInstanceAssociationsRequest(Mapping):
        pass

    class DescribeEffectiveInstanceAssociationsResult(Mapping):
        pass

    class DescribeEffectivePatchesForPatchBaselineRequest(Mapping):
        pass

    class DescribeEffectivePatchesForPatchBaselineResult(Mapping):
        pass

    class DescribeInstanceAssociationsStatusRequest(Mapping):
        pass

    class DescribeInstanceAssociationsStatusResult(Mapping):
        pass

    class DescribeInstanceInformationRequest(Mapping):
        pass

    class DescribeInstanceInformationResult(Mapping):
        pass

    class InstanceInformationFilter(Mapping):
        pass

    class InstanceInformationStringFilter(Mapping):
        pass

    class DescribeInstancePatchStatesRequest(Mapping):
        pass

    class DescribeInstancePatchStatesResult(Mapping):
        pass

    class DescribeInstancePatchStatesForPatchGroupRequest(Mapping):
        pass

    class DescribeInstancePatchStatesForPatchGroupResult(Mapping):
        pass

    class InstancePatchStateFilter(Mapping):
        pass

    class DescribeInstancePatchesRequest(Mapping):
        pass

    class DescribeInstancePatchesResult(Mapping):
        pass

    class DescribeInventoryDeletionsRequest(Mapping):
        pass

    class DescribeInventoryDeletionsResult(Mapping):
        pass

    class DescribeMaintenanceWindowExecutionTaskInvocationsRequest(Mapping):
        pass

    class DescribeMaintenanceWindowExecutionTaskInvocationsResult(Mapping):
        pass

    class MaintenanceWindowFilter(Mapping):
        pass

    class DescribeMaintenanceWindowExecutionTasksRequest(Mapping):
        pass

    class DescribeMaintenanceWindowExecutionTasksResult(Mapping):
        pass

    class DescribeMaintenanceWindowExecutionsRequest(Mapping):
        pass

    class DescribeMaintenanceWindowExecutionsResult(Mapping):
        pass

    class DescribeMaintenanceWindowScheduleRequest(Mapping):
        pass

    class DescribeMaintenanceWindowScheduleResult(Mapping):
        pass

    class DescribeMaintenanceWindowTargetsRequest(Mapping):
        pass

    class DescribeMaintenanceWindowTargetsResult(Mapping):
        pass

    class DescribeMaintenanceWindowTasksRequest(Mapping):
        pass

    class DescribeMaintenanceWindowTasksResult(Mapping):
        pass

    class DescribeMaintenanceWindowsRequest(Mapping):
        pass

    class DescribeMaintenanceWindowsResult(Mapping):
        pass

    class DescribeMaintenanceWindowsForTargetRequest(Mapping):
        pass

    class DescribeMaintenanceWindowsForTargetResult(Mapping):
        pass

    class DescribeParametersRequest(Mapping):
        pass

    class DescribeParametersResult(Mapping):
        pass

    class ParametersFilter(Mapping):
        pass

    class ParameterStringFilter(Mapping):
        pass

    class DescribePatchBaselinesRequest(Mapping):
        pass

    class DescribePatchBaselinesResult(Mapping):
        pass

    class DescribePatchGroupStateRequest(Mapping):
        pass

    class DescribePatchGroupStateResult(Mapping):
        pass

    class DescribePatchGroupsRequest(Mapping):
        pass

    class DescribePatchGroupsResult(Mapping):
        pass

    class DescribeSessionsRequest(Mapping):
        pass

    class DescribeSessionsResponse(Mapping):
        pass

    class SessionFilter(Mapping):
        pass

    class GetAutomationExecutionRequest(Mapping):
        pass

    class GetAutomationExecutionResult(Mapping):
        pass

    class GetCommandInvocationRequest(Mapping):
        pass

    class GetCommandInvocationResult(Mapping):
        pass

    class GetConnectionStatusRequest(Mapping):
        pass

    class GetConnectionStatusResponse(Mapping):
        pass

    class GetDefaultPatchBaselineRequest(Mapping):
        pass

    class GetDefaultPatchBaselineResult(Mapping):
        pass

    class GetDeployablePatchSnapshotForInstanceRequest(Mapping):
        pass

    class GetDeployablePatchSnapshotForInstanceResult(Mapping):
        pass

    class GetDocumentRequest(Mapping):
        pass

    class GetDocumentResult(Mapping):
        pass

    class GetInventoryRequest(Mapping):
        pass

    class GetInventoryResult(Mapping):
        pass

    class InventoryFilter(Mapping):
        pass

    class InventoryAggregator(Mapping):
        pass

    class ResultAttribute(Mapping):
        pass

    class GetInventorySchemaRequest(Mapping):
        pass

    class GetInventorySchemaResult(Mapping):
        pass

    class AggregatorSchemaOnly(object):
        pass

    class IsSubTypeSchema(object):
        pass

    class GetMaintenanceWindowRequest(Mapping):
        pass

    class GetMaintenanceWindowResult(Mapping):
        pass

    class GetMaintenanceWindowExecutionRequest(Mapping):
        pass

    class GetMaintenanceWindowExecutionResult(Mapping):
        pass

    class GetMaintenanceWindowExecutionTaskRequest(Mapping):
        pass

    class GetMaintenanceWindowExecutionTaskResult(Mapping):
        pass

    class GetMaintenanceWindowExecutionTaskInvocationRequest(Mapping):
        pass

    class GetMaintenanceWindowExecutionTaskInvocationResult(Mapping):
        pass

    class GetMaintenanceWindowTaskRequest(Mapping):
        pass

    class GetMaintenanceWindowTaskResult(Mapping):
        pass

    class GetParameterRequest(Mapping):
        pass

    class GetParameterResult(Mapping):
        pass

    class GetParameterHistoryRequest(Mapping):
        pass

    class GetParameterHistoryResult(Mapping):
        pass

    class GetParametersRequest(Mapping):
        pass

    class GetParametersResult(Mapping):
        pass

    class GetParametersByPathRequest(Mapping):
        pass

    class GetParametersByPathResult(Mapping):
        pass

    class GetPatchBaselineRequest(Mapping):
        pass

    class GetPatchBaselineResult(Mapping):
        pass

    class GetPatchBaselineForPatchGroupRequest(Mapping):
        pass

    class GetPatchBaselineForPatchGroupResult(Mapping):
        pass

    class LabelParameterVersionRequest(Mapping):
        pass

    class LabelParameterVersionResult(Mapping):
        pass

    class PSParameterVersion(object):
        pass

    class ParameterLabel(object):
        pass

    class ListAssociationVersionsRequest(Mapping):
        pass

    class ListAssociationVersionsResult(Mapping):
        pass

    class ListAssociationsRequest(Mapping):
        pass

    class ListAssociationsResult(Mapping):
        pass

    class AssociationFilter(Mapping):
        pass

    class ListCommandInvocationsRequest(Mapping):
        pass

    class ListCommandInvocationsResult(Mapping):
        pass

    class CommandFilter(Mapping):
        pass

    class ListCommandsRequest(Mapping):
        pass

    class ListCommandsResult(Mapping):
        pass

    class ListComplianceItemsRequest(Mapping):
        pass

    class ListComplianceItemsResult(Mapping):
        pass

    class ComplianceStringFilter(Mapping):
        pass

    class ComplianceResourceId(object):
        pass

    class ComplianceResourceType(object):
        pass

    class ListComplianceSummariesRequest(Mapping):
        pass

    class ListComplianceSummariesResult(Mapping):
        pass

    class ListDocumentVersionsRequest(Mapping):
        pass

    class ListDocumentVersionsResult(Mapping):
        pass

    class ListDocumentsRequest(Mapping):
        pass

    class ListDocumentsResult(Mapping):
        pass

    class DocumentFilter(Mapping):
        pass

    class DocumentKeyValuesFilter(Mapping):
        pass

    class ListInventoryEntriesRequest(Mapping):
        pass

    class ListInventoryEntriesResult(Mapping):
        pass

    class ListResourceComplianceSummariesRequest(Mapping):
        pass

    class ListResourceComplianceSummariesResult(Mapping):
        pass

    class ListResourceDataSyncRequest(Mapping):
        pass

    class ListResourceDataSyncResult(Mapping):
        pass

    class ListTagsForResourceRequest(Mapping):
        pass

    class ListTagsForResourceResult(Mapping):
        pass

    class ModifyDocumentPermissionRequest(Mapping):
        pass

    class ModifyDocumentPermissionResponse(Mapping):
        pass

    class AccountId(object):
        pass

    class PutComplianceItemsRequest(Mapping):
        pass

    class PutComplianceItemsResult(Mapping):
        pass

    class ComplianceExecutionSummary(Mapping):
        pass

    class ComplianceItemEntry(Mapping):
        pass

    class PutInventoryRequest(Mapping):
        pass

    class PutInventoryResult(Mapping):
        pass

    class InventoryItem(Mapping):
        pass

    class PutParameterRequest(Mapping):
        pass

    class PutParameterResult(Mapping):
        pass

    class RegisterDefaultPatchBaselineRequest(Mapping):
        pass

    class RegisterDefaultPatchBaselineResult(Mapping):
        pass

    class RegisterPatchBaselineForPatchGroupRequest(Mapping):
        pass

    class RegisterPatchBaselineForPatchGroupResult(Mapping):
        pass

    class RegisterTargetWithMaintenanceWindowRequest(Mapping):
        pass

    class RegisterTargetWithMaintenanceWindowResult(Mapping):
        pass

    class RegisterTaskWithMaintenanceWindowRequest(Mapping):
        pass

    class RegisterTaskWithMaintenanceWindowResult(Mapping):
        pass

    class MaintenanceWindowTaskParameters(object):
        pass

    class MaintenanceWindowTaskInvocationParameters(Mapping):
        pass

    class LoggingInfo(Mapping):
        pass

    class RemoveTagsFromResourceRequest(Mapping):
        pass

    class RemoveTagsFromResourceResult(Mapping):
        pass

    class TagKey(object):
        pass

    class ResumeSessionRequest(Mapping):
        pass

    class ResumeSessionResponse(Mapping):
        pass

    class SendAutomationSignalRequest(Mapping):
        pass

    class SendAutomationSignalResult(Mapping):
        pass

    class AutomationParameterMap(object):
        pass

    class SendCommandRequest(Mapping):
        pass

    class SendCommandResult(Mapping):
        pass

    class NotificationConfig(Mapping):
        pass

    class CloudWatchOutputConfig(Mapping):
        pass

    class StartAssociationsOnceRequest(Mapping):
        pass

    class StartAssociationsOnceResult(Mapping):
        pass

    class AssociationId(object):
        pass

    class StartAutomationExecutionRequest(Mapping):
        pass

    class StartAutomationExecutionResult(Mapping):
        pass

    class TargetMap(object):
        pass

    class TargetLocation(Mapping):
        pass

    class StartSessionRequest(Mapping):
        pass

    class StartSessionResponse(Mapping):
        pass

    class SessionManagerParameters(object):
        pass

    class StopAutomationExecutionRequest(Mapping):
        pass

    class StopAutomationExecutionResult(Mapping):
        pass

    class TerminateSessionRequest(Mapping):
        pass

    class TerminateSessionResponse(Mapping):
        pass

    class UpdateAssociationRequest(Mapping):
        pass

    class UpdateAssociationResult(Mapping):
        pass

    class UpdateAssociationStatusRequest(Mapping):
        pass

    class UpdateAssociationStatusResult(Mapping):
        pass

    class AssociationStatus(Mapping):
        pass

    class UpdateDocumentRequest(Mapping):
        pass

    class UpdateDocumentResult(Mapping):
        pass

    class UpdateDocumentDefaultVersionRequest(Mapping):
        pass

    class UpdateDocumentDefaultVersionResult(Mapping):
        pass

    class UpdateMaintenanceWindowRequest(Mapping):
        pass

    class UpdateMaintenanceWindowResult(Mapping):
        pass

    class MaintenanceWindowEnabled(object):
        pass

    class UpdateMaintenanceWindowTargetRequest(Mapping):
        pass

    class UpdateMaintenanceWindowTargetResult(Mapping):
        pass

    class UpdateMaintenanceWindowTaskRequest(Mapping):
        pass

    class UpdateMaintenanceWindowTaskResult(Mapping):
        pass

    class UpdateManagedInstanceRoleRequest(Mapping):
        pass

    class UpdateManagedInstanceRoleResult(Mapping):
        pass

    class UpdatePatchBaselineRequest(Mapping):
        pass

    class UpdatePatchBaselineResult(Mapping):
        pass

    def add_tags_to_resource(self, Tags: List[Tag], ResourceId: str, ResourceType: str) -> AddTagsToResourceResult:
        pass

    def cancel_command(self, CommandId: str, InstanceIds: List[InstanceId]=None) -> CancelCommandResult:
        pass

    def cancel_maintenance_window_execution(self, WindowExecutionId: str) -> CancelMaintenanceWindowExecutionResult:
        pass

    def create_activation(self, IamRole: str, Description: str=None, DefaultInstanceName: str=None, RegistrationLimit: int=None, ExpirationDate: ExpirationDate=None) -> CreateActivationResult:
        pass

    def create_association(self, Name: str, DocumentVersion: str=None, InstanceId: str=None, Parameters: Parameters=None, Targets: List[Target]=None, ScheduleExpression: str=None, OutputLocation: InstanceAssociationOutputLocation=None, AssociationName: str=None, AutomationTargetParameterName: str=None, MaxErrors: str=None, MaxConcurrency: str=None, ComplianceSeverity: str=None) -> CreateAssociationResult:
        pass

    def create_association_batch(self, Entries: List[CreateAssociationBatchRequestEntry]) -> CreateAssociationBatchResult:
        pass

    def create_document(self, Name: str, Content: str, Attachments: List[AttachmentsSource]=None, VersionName: str=None, DocumentType: str=None, DocumentFormat: str=None, TargetType: str=None) -> CreateDocumentResult:
        pass

    def create_maintenance_window(self, AllowUnassociatedTargets: MaintenanceWindowAllowUnassociatedTargets, Cutoff: int, Duration: int, Schedule: str, Name: str, Description: str=None, StartDate: str=None, EndDate: str=None, ScheduleTimezone: str=None, ClientToken: str=None) -> CreateMaintenanceWindowResult:
        pass

    def create_patch_baseline(self, Name: str, OperatingSystem: str=None, GlobalFilters: PatchFilterGroup=None, ApprovalRules: PatchRuleGroup=None, ApprovedPatches: List[PatchId]=None, ApprovedPatchesComplianceLevel: str=None, ApprovedPatchesEnableNonSecurity: Boolean=None, RejectedPatches: List[PatchId]=None, RejectedPatchesAction: str=None, Description: str=None, Sources: List[PatchSource]=None, ClientToken: str=None) -> CreatePatchBaselineResult:
        pass

    def create_resource_data_sync(self, S3Destination: ResourceDataSyncS3Destination, SyncName: str) -> CreateResourceDataSyncResult:
        pass

    def delete_activation(self, ActivationId: str) -> DeleteActivationResult:
        pass

    def delete_association(self, Name: str=None, InstanceId: str=None, AssociationId: str=None) -> DeleteAssociationResult:
        pass

    def delete_document(self, Name: str) -> DeleteDocumentResult:
        pass

    def delete_inventory(self, TypeName: str, SchemaDeleteOption: str=None, DryRun: DryRun=None, ClientToken: str=None) -> DeleteInventoryResult:
        pass

    def delete_maintenance_window(self, WindowId: str) -> DeleteMaintenanceWindowResult:
        pass

    def delete_parameter(self, Name: str) -> DeleteParameterResult:
        pass

    def delete_parameters(self, Names: List[PSParameterName]) -> DeleteParametersResult:
        pass

    def delete_patch_baseline(self, BaselineId: str) -> DeletePatchBaselineResult:
        pass

    def delete_resource_data_sync(self, SyncName: str) -> DeleteResourceDataSyncResult:
        pass

    def deregister_managed_instance(self, InstanceId: str) -> DeregisterManagedInstanceResult:
        pass

    def deregister_patch_baseline_for_patch_group(self, PatchGroup: str, BaselineId: str) -> DeregisterPatchBaselineForPatchGroupResult:
        pass

    def deregister_target_from_maintenance_window(self, WindowTargetId: str, WindowId: str, Safe: Boolean=None) -> DeregisterTargetFromMaintenanceWindowResult:
        pass

    def deregister_task_from_maintenance_window(self, WindowTaskId: str, WindowId: str) -> DeregisterTaskFromMaintenanceWindowResult:
        pass

    def describe_activations(self, Filters: List[DescribeActivationsFilter]=None, MaxResults: int=None, NextToken: str=None) -> DescribeActivationsResult:
        pass

    def describe_association(self, Name: str=None, InstanceId: str=None, AssociationId: str=None, AssociationVersion: str=None) -> DescribeAssociationResult:
        pass

    def describe_association_execution_targets(self, ExecutionId: str, AssociationId: str, Filters: List[AssociationExecutionTargetsFilter]=None, MaxResults: int=None, NextToken: str=None) -> DescribeAssociationExecutionTargetsResult:
        pass

    def describe_association_executions(self, AssociationId: str, Filters: List[AssociationExecutionFilter]=None, MaxResults: int=None, NextToken: str=None) -> DescribeAssociationExecutionsResult:
        pass

    def describe_automation_executions(self, Filters: List[AutomationExecutionFilter]=None, MaxResults: int=None, NextToken: str=None) -> DescribeAutomationExecutionsResult:
        pass

    def describe_automation_step_executions(self, AutomationExecutionId: str, Filters: List[StepExecutionFilter]=None, NextToken: str=None, MaxResults: int=None, ReverseOrder: Boolean=None) -> DescribeAutomationStepExecutionsResult:
        pass

    def describe_available_patches(self, Filters: List[PatchOrchestratorFilter]=None, MaxResults: int=None, NextToken: str=None) -> DescribeAvailablePatchesResult:
        pass

    def describe_document(self, Name: str, DocumentVersion: str=None, VersionName: str=None) -> DescribeDocumentResult:
        pass

    def describe_document_permission(self, PermissionType: str, Name: str) -> DescribeDocumentPermissionResponse:
        pass

    def describe_effective_instance_associations(self, InstanceId: str, MaxResults: int=None, NextToken: str=None) -> DescribeEffectiveInstanceAssociationsResult:
        pass

    def describe_effective_patches_for_patch_baseline(self, BaselineId: str, MaxResults: int=None, NextToken: str=None) -> DescribeEffectivePatchesForPatchBaselineResult:
        pass

    def describe_instance_associations_status(self, InstanceId: str, MaxResults: int=None, NextToken: str=None) -> DescribeInstanceAssociationsStatusResult:
        pass

    def describe_instance_information(self, InstanceInformationFilterList: List[InstanceInformationFilter]=None, Filters: List[InstanceInformationStringFilter]=None, MaxResults: int=None, NextToken: str=None) -> DescribeInstanceInformationResult:
        pass

    def describe_instance_patch_states(self, InstanceIds: List[InstanceId], NextToken: str=None, MaxResults: int=None) -> DescribeInstancePatchStatesResult:
        pass

    def describe_instance_patch_states_for_patch_group(self, PatchGroup: str, Filters: List[InstancePatchStateFilter]=None, NextToken: str=None, MaxResults: int=None) -> DescribeInstancePatchStatesForPatchGroupResult:
        pass

    def describe_instance_patches(self, InstanceId: str, Filters: List[PatchOrchestratorFilter]=None, NextToken: str=None, MaxResults: int=None) -> DescribeInstancePatchesResult:
        pass

    def describe_inventory_deletions(self, DeletionId: str=None, NextToken: str=None, MaxResults: int=None) -> DescribeInventoryDeletionsResult:
        pass

    def describe_maintenance_window_execution_task_invocations(self, TaskId: str, WindowExecutionId: str, Filters: List[MaintenanceWindowFilter]=None, MaxResults: int=None, NextToken: str=None) -> DescribeMaintenanceWindowExecutionTaskInvocationsResult:
        pass

    def describe_maintenance_window_execution_tasks(self, WindowExecutionId: str, Filters: List[MaintenanceWindowFilter]=None, MaxResults: int=None, NextToken: str=None) -> DescribeMaintenanceWindowExecutionTasksResult:
        pass

    def describe_maintenance_window_executions(self, WindowId: str, Filters: List[MaintenanceWindowFilter]=None, MaxResults: int=None, NextToken: str=None) -> DescribeMaintenanceWindowExecutionsResult:
        pass

    def describe_maintenance_window_schedule(self, WindowId: str=None, Targets: List[Target]=None, ResourceType: str=None, Filters: List[PatchOrchestratorFilter]=None, MaxResults: int=None, NextToken: str=None) -> DescribeMaintenanceWindowScheduleResult:
        pass

    def describe_maintenance_window_targets(self, WindowId: str, Filters: List[MaintenanceWindowFilter]=None, MaxResults: int=None, NextToken: str=None) -> DescribeMaintenanceWindowTargetsResult:
        pass

    def describe_maintenance_window_tasks(self, WindowId: str, Filters: List[MaintenanceWindowFilter]=None, MaxResults: int=None, NextToken: str=None) -> DescribeMaintenanceWindowTasksResult:
        pass

    def describe_maintenance_windows(self, Filters: List[MaintenanceWindowFilter]=None, MaxResults: int=None, NextToken: str=None) -> DescribeMaintenanceWindowsResult:
        pass

    def describe_maintenance_windows_for_target(self, ResourceType: str, Targets: List[Target], MaxResults: int=None, NextToken: str=None) -> DescribeMaintenanceWindowsForTargetResult:
        pass

    def describe_parameters(self, Filters: List[ParametersFilter]=None, ParameterFilters: List[ParameterStringFilter]=None, MaxResults: int=None, NextToken: str=None) -> DescribeParametersResult:
        pass

    def describe_patch_baselines(self, Filters: List[PatchOrchestratorFilter]=None, MaxResults: int=None, NextToken: str=None) -> DescribePatchBaselinesResult:
        pass

    def describe_patch_group_state(self, PatchGroup: str) -> DescribePatchGroupStateResult:
        pass

    def describe_patch_groups(self, MaxResults: int=None, Filters: List[PatchOrchestratorFilter]=None, NextToken: str=None) -> DescribePatchGroupsResult:
        pass

    def describe_sessions(self, State: str, MaxResults: int=None, NextToken: str=None, Filters: List[SessionFilter]=None) -> DescribeSessionsResponse:
        pass

    def get_automation_execution(self, AutomationExecutionId: str) -> GetAutomationExecutionResult:
        pass

    def get_command_invocation(self, InstanceId: str, CommandId: str, PluginName: str=None) -> GetCommandInvocationResult:
        pass

    def get_connection_status(self, Target: str) -> GetConnectionStatusResponse:
        pass

    def get_default_patch_baseline(self, OperatingSystem: str=None) -> GetDefaultPatchBaselineResult:
        pass

    def get_deployable_patch_snapshot_for_instance(self, SnapshotId: str, InstanceId: str) -> GetDeployablePatchSnapshotForInstanceResult:
        pass

    def get_document(self, Name: str, VersionName: str=None, DocumentVersion: str=None, DocumentFormat: str=None) -> GetDocumentResult:
        pass

    def get_inventory(self, Filters: List[InventoryFilter]=None, Aggregators: List[InventoryAggregator]=None, ResultAttributes: List[ResultAttribute]=None, NextToken: str=None, MaxResults: int=None) -> GetInventoryResult:
        pass

    def get_inventory_schema(self, TypeName: str=None, NextToken: str=None, MaxResults: int=None, Aggregator: AggregatorSchemaOnly=None, SubType: IsSubTypeSchema=None) -> GetInventorySchemaResult:
        pass

    def get_maintenance_window(self, WindowId: str) -> GetMaintenanceWindowResult:
        pass

    def get_maintenance_window_execution(self, WindowExecutionId: str) -> GetMaintenanceWindowExecutionResult:
        pass

    def get_maintenance_window_execution_task(self, TaskId: str, WindowExecutionId: str) -> GetMaintenanceWindowExecutionTaskResult:
        pass

    def get_maintenance_window_execution_task_invocation(self, InvocationId: str, TaskId: str, WindowExecutionId: str) -> GetMaintenanceWindowExecutionTaskInvocationResult:
        pass

    def get_maintenance_window_task(self, WindowTaskId: str, WindowId: str) -> GetMaintenanceWindowTaskResult:
        pass

    def get_parameter(self, Name: str, WithDecryption: Boolean=None) -> GetParameterResult:
        pass

    def get_parameter_history(self, Name: str, WithDecryption: Boolean=None, MaxResults: int=None, NextToken: str=None) -> GetParameterHistoryResult:
        pass

    def get_parameters(self, Names: List[PSParameterName], WithDecryption: Boolean=None) -> GetParametersResult:
        pass

    def get_parameters_by_path(self, Path: str, Recursive: Boolean=None, ParameterFilters: List[ParameterStringFilter]=None, WithDecryption: Boolean=None, MaxResults: int=None, NextToken: str=None) -> GetParametersByPathResult:
        pass

    def get_patch_baseline(self, BaselineId: str) -> GetPatchBaselineResult:
        pass

    def get_patch_baseline_for_patch_group(self, PatchGroup: str, OperatingSystem: str=None) -> GetPatchBaselineForPatchGroupResult:
        pass

    def label_parameter_version(self, Labels: List[ParameterLabel], Name: str, ParameterVersion: PSParameterVersion=None) -> LabelParameterVersionResult:
        pass

    def list_association_versions(self, AssociationId: str, MaxResults: int=None, NextToken: str=None) -> ListAssociationVersionsResult:
        pass

    def list_associations(self, AssociationFilterList: List[AssociationFilter]=None, MaxResults: int=None, NextToken: str=None) -> ListAssociationsResult:
        pass

    def list_command_invocations(self, CommandId: str=None, InstanceId: str=None, MaxResults: int=None, NextToken: str=None, Filters: List[CommandFilter]=None, Details: Boolean=None) -> ListCommandInvocationsResult:
        pass

    def list_commands(self, CommandId: str=None, InstanceId: str=None, MaxResults: int=None, NextToken: str=None, Filters: List[CommandFilter]=None) -> ListCommandsResult:
        pass

    def list_compliance_items(self, Filters: List[ComplianceStringFilter]=None, ResourceIds: List[ComplianceResourceId]=None, ResourceTypes: List[ComplianceResourceType]=None, NextToken: str=None, MaxResults: int=None) -> ListComplianceItemsResult:
        pass

    def list_compliance_summaries(self, Filters: List[ComplianceStringFilter]=None, NextToken: str=None, MaxResults: int=None) -> ListComplianceSummariesResult:
        pass

    def list_document_versions(self, Name: str, MaxResults: int=None, NextToken: str=None) -> ListDocumentVersionsResult:
        pass

    def list_documents(self, DocumentFilterList: List[DocumentFilter]=None, Filters: List[DocumentKeyValuesFilter]=None, MaxResults: int=None, NextToken: str=None) -> ListDocumentsResult:
        pass

    def list_inventory_entries(self, TypeName: str, InstanceId: str, Filters: List[InventoryFilter]=None, NextToken: str=None, MaxResults: int=None) -> ListInventoryEntriesResult:
        pass

    def list_resource_compliance_summaries(self, Filters: List[ComplianceStringFilter]=None, NextToken: str=None, MaxResults: int=None) -> ListResourceComplianceSummariesResult:
        pass

    def list_resource_data_sync(self, NextToken: str=None, MaxResults: int=None) -> ListResourceDataSyncResult:
        pass

    def list_tags_for_resource(self, ResourceId: str, ResourceType: str) -> ListTagsForResourceResult:
        pass

    def modify_document_permission(self, PermissionType: str, Name: str, AccountIdsToAdd: List[AccountId]=None, AccountIdsToRemove: List[AccountId]=None) -> ModifyDocumentPermissionResponse:
        pass

    def put_compliance_items(self, Items: List[ComplianceItemEntry], ExecutionSummary: ComplianceExecutionSummary, ComplianceType: str, ResourceType: str, ResourceId: str, ItemContentHash: str=None) -> PutComplianceItemsResult:
        pass

    def put_inventory(self, Items: List[InventoryItem], InstanceId: str) -> PutInventoryResult:
        pass

    def put_parameter(self, Type: str, Value: str, Name: str, Description: str=None, KeyId: str=None, Overwrite: Boolean=None, AllowedPattern: str=None) -> PutParameterResult:
        pass

    def register_default_patch_baseline(self, BaselineId: str) -> RegisterDefaultPatchBaselineResult:
        pass

    def register_patch_baseline_for_patch_group(self, PatchGroup: str, BaselineId: str) -> RegisterPatchBaselineForPatchGroupResult:
        pass

    def register_target_with_maintenance_window(self, Targets: List[Target], ResourceType: str, WindowId: str, OwnerInformation: str=None, Name: str=None, Description: str=None, ClientToken: str=None) -> RegisterTargetWithMaintenanceWindowResult:
        pass

    def register_task_with_maintenance_window(self, MaxErrors: str, MaxConcurrency: str, TaskType: str, TaskArn: str, Targets: List[Target], WindowId: str, ServiceRoleArn: str=None, TaskParameters: MaintenanceWindowTaskParameters=None, TaskInvocationParameters: MaintenanceWindowTaskInvocationParameters=None, Priority: int=None, LoggingInfo: LoggingInfo=None, Name: str=None, Description: str=None, ClientToken: str=None) -> RegisterTaskWithMaintenanceWindowResult:
        pass

    def remove_tags_from_resource(self, TagKeys: List[TagKey], ResourceId: str, ResourceType: str) -> RemoveTagsFromResourceResult:
        pass

    def resume_session(self, SessionId: str) -> ResumeSessionResponse:
        pass

    def send_automation_signal(self, SignalType: str, AutomationExecutionId: str, Payload: AutomationParameterMap=None) -> SendAutomationSignalResult:
        pass

    def send_command(self, DocumentName: str, InstanceIds: List[InstanceId]=None, Targets: List[Target]=None, DocumentVersion: str=None, DocumentHash: str=None, DocumentHashType: str=None, TimeoutSeconds: int=None, Comment: str=None, Parameters: Parameters=None, OutputS3Region: str=None, OutputS3BucketName: str=None, OutputS3KeyPrefix: str=None, MaxConcurrency: str=None, MaxErrors: str=None, ServiceRoleArn: str=None, NotificationConfig: NotificationConfig=None, CloudWatchOutputConfig: CloudWatchOutputConfig=None) -> SendCommandResult:
        pass

    def start_associations_once(self, AssociationIds: List[AssociationId]) -> StartAssociationsOnceResult:
        pass

    def start_automation_execution(self, DocumentName: str, DocumentVersion: str=None, Parameters: AutomationParameterMap=None, ClientToken: str=None, Mode: str=None, TargetParameterName: str=None, Targets: List[Target]=None, TargetMaps: List[TargetMap]=None, MaxConcurrency: str=None, MaxErrors: str=None, TargetLocations: List[TargetLocation]=None) -> StartAutomationExecutionResult:
        pass

    def start_session(self, Target: str, DocumentName: str=None, Parameters: SessionManagerParameters=None) -> StartSessionResponse:
        pass

    def stop_automation_execution(self, AutomationExecutionId: str, Type: str=None) -> StopAutomationExecutionResult:
        pass

    def terminate_session(self, SessionId: str) -> TerminateSessionResponse:
        pass

    def update_association(self, AssociationId: str, Parameters: Parameters=None, DocumentVersion: str=None, ScheduleExpression: str=None, OutputLocation: InstanceAssociationOutputLocation=None, Name: str=None, Targets: List[Target]=None, AssociationName: str=None, AssociationVersion: str=None, AutomationTargetParameterName: str=None, MaxErrors: str=None, MaxConcurrency: str=None, ComplianceSeverity: str=None) -> UpdateAssociationResult:
        pass

    def update_association_status(self, AssociationStatus: AssociationStatus, InstanceId: str, Name: str) -> UpdateAssociationStatusResult:
        pass

    def update_document(self, Name: str, Content: str, Attachments: List[AttachmentsSource]=None, VersionName: str=None, DocumentVersion: str=None, DocumentFormat: str=None, TargetType: str=None) -> UpdateDocumentResult:
        pass

    def update_document_default_version(self, DocumentVersion: str, Name: str) -> UpdateDocumentDefaultVersionResult:
        pass

    def update_maintenance_window(self, WindowId: str, Name: str=None, Description: str=None, StartDate: str=None, EndDate: str=None, Schedule: str=None, ScheduleTimezone: str=None, Duration: int=None, Cutoff: int=None, AllowUnassociatedTargets: MaintenanceWindowAllowUnassociatedTargets=None, Enabled: MaintenanceWindowEnabled=None, Replace: Boolean=None) -> UpdateMaintenanceWindowResult:
        pass

    def update_maintenance_window_target(self, WindowTargetId: str, WindowId: str, Targets: List[Target]=None, OwnerInformation: str=None, Name: str=None, Description: str=None, Replace: Boolean=None) -> UpdateMaintenanceWindowTargetResult:
        pass

    def update_maintenance_window_task(self, WindowTaskId: str, WindowId: str, Targets: List[Target]=None, TaskArn: str=None, ServiceRoleArn: str=None, TaskParameters: MaintenanceWindowTaskParameters=None, TaskInvocationParameters: MaintenanceWindowTaskInvocationParameters=None, Priority: int=None, MaxConcurrency: str=None, MaxErrors: str=None, LoggingInfo: LoggingInfo=None, Name: str=None, Description: str=None, Replace: Boolean=None) -> UpdateMaintenanceWindowTaskResult:
        pass

    def update_managed_instance_role(self, IamRole: str, InstanceId: str) -> UpdateManagedInstanceRoleResult:
        pass

    def update_patch_baseline(self, BaselineId: str, Name: str=None, GlobalFilters: PatchFilterGroup=None, ApprovalRules: PatchRuleGroup=None, ApprovedPatches: List[PatchId]=None, ApprovedPatchesComplianceLevel: str=None, ApprovedPatchesEnableNonSecurity: Boolean=None, RejectedPatches: List[PatchId]=None, RejectedPatchesAction: str=None, Description: str=None, Sources: List[PatchSource]=None, Replace: Boolean=None) -> UpdatePatchBaselineResult:
        pass


class SFN(BaseClient):
    class CreateActivityInput(Mapping):
        pass

    class CreateActivityOutput(Mapping):
        pass

    class CreateStateMachineInput(Mapping):
        pass

    class CreateStateMachineOutput(Mapping):
        pass

    class DeleteActivityInput(Mapping):
        pass

    class DeleteActivityOutput(Mapping):
        pass

    class DeleteStateMachineInput(Mapping):
        pass

    class DeleteStateMachineOutput(Mapping):
        pass

    class DescribeActivityInput(Mapping):
        pass

    class DescribeActivityOutput(Mapping):
        pass

    class DescribeExecutionInput(Mapping):
        pass

    class DescribeExecutionOutput(Mapping):
        pass

    class DescribeStateMachineInput(Mapping):
        pass

    class DescribeStateMachineOutput(Mapping):
        pass

    class DescribeStateMachineForExecutionInput(Mapping):
        pass

    class DescribeStateMachineForExecutionOutput(Mapping):
        pass

    class GetActivityTaskInput(Mapping):
        pass

    class GetActivityTaskOutput(Mapping):
        pass

    class GetExecutionHistoryInput(Mapping):
        pass

    class GetExecutionHistoryOutput(Mapping):
        pass

    class ReverseOrder(object):
        pass

    class ListActivitiesInput(Mapping):
        pass

    class ListActivitiesOutput(Mapping):
        pass

    class ListExecutionsInput(Mapping):
        pass

    class ListExecutionsOutput(Mapping):
        pass

    class ListStateMachinesInput(Mapping):
        pass

    class ListStateMachinesOutput(Mapping):
        pass

    class ListTagsForResourceInput(Mapping):
        pass

    class ListTagsForResourceOutput(Mapping):
        pass

    class SendTaskFailureInput(Mapping):
        pass

    class SendTaskFailureOutput(Mapping):
        pass

    class SendTaskHeartbeatInput(Mapping):
        pass

    class SendTaskHeartbeatOutput(Mapping):
        pass

    class SendTaskSuccessInput(Mapping):
        pass

    class SendTaskSuccessOutput(Mapping):
        pass

    class StartExecutionInput(Mapping):
        pass

    class StartExecutionOutput(Mapping):
        pass

    class StopExecutionInput(Mapping):
        pass

    class StopExecutionOutput(Mapping):
        pass

    class TagResourceInput(Mapping):
        pass

    class TagResourceOutput(Mapping):
        pass

    class Tag(Mapping):
        pass

    class UntagResourceInput(Mapping):
        pass

    class UntagResourceOutput(Mapping):
        pass

    class TagKey(object):
        pass

    class UpdateStateMachineInput(Mapping):
        pass

    class UpdateStateMachineOutput(Mapping):
        pass

    def create_activity(self, name: str) -> CreateActivityOutput:
        pass

    def create_state_machine(self, roleArn: str, definition: str, name: str) -> CreateStateMachineOutput:
        pass

    def delete_activity(self, activityArn: str) -> DeleteActivityOutput:
        pass

    def delete_state_machine(self, stateMachineArn: str) -> DeleteStateMachineOutput:
        pass

    def describe_activity(self, activityArn: str) -> DescribeActivityOutput:
        pass

    def describe_execution(self, executionArn: str) -> DescribeExecutionOutput:
        pass

    def describe_state_machine(self, stateMachineArn: str) -> DescribeStateMachineOutput:
        pass

    def describe_state_machine_for_execution(self, executionArn: str) -> DescribeStateMachineForExecutionOutput:
        pass

    def get_activity_task(self, activityArn: str, workerName: str=None) -> GetActivityTaskOutput:
        pass

    def get_execution_history(self, executionArn: str, maxResults: int=None, reverseOrder: ReverseOrder=None, nextToken: str=None) -> GetExecutionHistoryOutput:
        pass

    def list_activities(self, maxResults: int=None, nextToken: str=None) -> ListActivitiesOutput:
        pass

    def list_executions(self, stateMachineArn: str, statusFilter: str=None, maxResults: int=None, nextToken: str=None) -> ListExecutionsOutput:
        pass

    def list_state_machines(self, maxResults: int=None, nextToken: str=None) -> ListStateMachinesOutput:
        pass

    def list_tags_for_resource(self, resourceArn: str) -> ListTagsForResourceOutput:
        pass

    def send_task_failure(self, taskToken: str, error: str=None, cause: str=None) -> SendTaskFailureOutput:
        pass

    def send_task_heartbeat(self, taskToken: str) -> SendTaskHeartbeatOutput:
        pass

    def send_task_success(self, output: str, taskToken: str) -> SendTaskSuccessOutput:
        pass

    def start_execution(self, stateMachineArn: str, name: str=None, input: str=None) -> StartExecutionOutput:
        pass

    def stop_execution(self, executionArn: str, error: str=None, cause: str=None) -> StopExecutionOutput:
        pass

    def tag_resource(self, tags: List[Tag], resourceArn: str) -> TagResourceOutput:
        pass

    def untag_resource(self, tagKeys: List[TagKey], resourceArn: str) -> UntagResourceOutput:
        pass

    def update_state_machine(self, stateMachineArn: str, definition: str=None, roleArn: str=None) -> UpdateStateMachineOutput:
        pass


class StorageGateway(BaseClient):
    class ActivateGatewayInput(Mapping):
        pass

    class ActivateGatewayOutput(Mapping):
        pass

    class AddCacheInput(Mapping):
        pass

    class AddCacheOutput(Mapping):
        pass

    class DiskId(object):
        pass

    class AddTagsToResourceInput(Mapping):
        pass

    class AddTagsToResourceOutput(Mapping):
        pass

    class Tag(Mapping):
        pass

    class AddUploadBufferInput(Mapping):
        pass

    class AddUploadBufferOutput(Mapping):
        pass

    class AddWorkingStorageInput(Mapping):
        pass

    class AddWorkingStorageOutput(Mapping):
        pass

    class AttachVolumeInput(Mapping):
        pass

    class AttachVolumeOutput(Mapping):
        pass

    class CancelArchivalInput(Mapping):
        pass

    class CancelArchivalOutput(Mapping):
        pass

    class CancelRetrievalInput(Mapping):
        pass

    class CancelRetrievalOutput(Mapping):
        pass

    class CreateCachediSCSIVolumeInput(Mapping):
        pass

    class CreateCachediSCSIVolumeOutput(Mapping):
        pass

    class long(object):
        pass

    class Boolean(object):
        pass

    class CreateNFSFileShareInput(Mapping):
        pass

    class CreateNFSFileShareOutput(Mapping):
        pass

    class NFSFileShareDefaults(Mapping):
        pass

    class IPV4AddressCIDR(object):
        pass

    class CreateSMBFileShareInput(Mapping):
        pass

    class CreateSMBFileShareOutput(Mapping):
        pass

    class FileShareUser(object):
        pass

    class CreateSnapshotInput(Mapping):
        pass

    class CreateSnapshotOutput(Mapping):
        pass

    class CreateSnapshotFromVolumeRecoveryPointInput(Mapping):
        pass

    class CreateSnapshotFromVolumeRecoveryPointOutput(Mapping):
        pass

    class CreateStorediSCSIVolumeInput(Mapping):
        pass

    class CreateStorediSCSIVolumeOutput(Mapping):
        pass

    class boolean(object):
        pass

    class CreateTapeWithBarcodeInput(Mapping):
        pass

    class CreateTapeWithBarcodeOutput(Mapping):
        pass

    class TapeSize(object):
        pass

    class CreateTapesInput(Mapping):
        pass

    class CreateTapesOutput(Mapping):
        pass

    class DeleteBandwidthRateLimitInput(Mapping):
        pass

    class DeleteBandwidthRateLimitOutput(Mapping):
        pass

    class DeleteChapCredentialsInput(Mapping):
        pass

    class DeleteChapCredentialsOutput(Mapping):
        pass

    class DeleteFileShareInput(Mapping):
        pass

    class DeleteFileShareOutput(Mapping):
        pass

    class DeleteGatewayInput(Mapping):
        pass

    class DeleteGatewayOutput(Mapping):
        pass

    class DeleteSnapshotScheduleInput(Mapping):
        pass

    class DeleteSnapshotScheduleOutput(Mapping):
        pass

    class DeleteTapeInput(Mapping):
        pass

    class DeleteTapeOutput(Mapping):
        pass

    class DeleteTapeArchiveInput(Mapping):
        pass

    class DeleteTapeArchiveOutput(Mapping):
        pass

    class DeleteVolumeInput(Mapping):
        pass

    class DeleteVolumeOutput(Mapping):
        pass

    class DescribeBandwidthRateLimitInput(Mapping):
        pass

    class DescribeBandwidthRateLimitOutput(Mapping):
        pass

    class DescribeCacheInput(Mapping):
        pass

    class DescribeCacheOutput(Mapping):
        pass

    class DescribeCachediSCSIVolumesInput(Mapping):
        pass

    class DescribeCachediSCSIVolumesOutput(Mapping):
        pass

    class VolumeARN(object):
        pass

    class DescribeChapCredentialsInput(Mapping):
        pass

    class DescribeChapCredentialsOutput(Mapping):
        pass

    class DescribeGatewayInformationInput(Mapping):
        pass

    class DescribeGatewayInformationOutput(Mapping):
        pass

    class DescribeMaintenanceStartTimeInput(Mapping):
        pass

    class DescribeMaintenanceStartTimeOutput(Mapping):
        pass

    class DescribeNFSFileSharesInput(Mapping):
        pass

    class DescribeNFSFileSharesOutput(Mapping):
        pass

    class FileShareARN(object):
        pass

    class DescribeSMBFileSharesInput(Mapping):
        pass

    class DescribeSMBFileSharesOutput(Mapping):
        pass

    class DescribeSMBSettingsInput(Mapping):
        pass

    class DescribeSMBSettingsOutput(Mapping):
        pass

    class DescribeSnapshotScheduleInput(Mapping):
        pass

    class DescribeSnapshotScheduleOutput(Mapping):
        pass

    class DescribeStorediSCSIVolumesInput(Mapping):
        pass

    class DescribeStorediSCSIVolumesOutput(Mapping):
        pass

    class DescribeTapeArchivesInput(Mapping):
        pass

    class DescribeTapeArchivesOutput(Mapping):
        pass

    class TapeARN(object):
        pass

    class DescribeTapeRecoveryPointsInput(Mapping):
        pass

    class DescribeTapeRecoveryPointsOutput(Mapping):
        pass

    class DescribeTapesInput(Mapping):
        pass

    class DescribeTapesOutput(Mapping):
        pass

    class DescribeUploadBufferInput(Mapping):
        pass

    class DescribeUploadBufferOutput(Mapping):
        pass

    class DescribeVTLDevicesInput(Mapping):
        pass

    class DescribeVTLDevicesOutput(Mapping):
        pass

    class VTLDeviceARN(object):
        pass

    class DescribeWorkingStorageInput(Mapping):
        pass

    class DescribeWorkingStorageOutput(Mapping):
        pass

    class DetachVolumeInput(Mapping):
        pass

    class DetachVolumeOutput(Mapping):
        pass

    class DisableGatewayInput(Mapping):
        pass

    class DisableGatewayOutput(Mapping):
        pass

    class JoinDomainInput(Mapping):
        pass

    class JoinDomainOutput(Mapping):
        pass

    class Host(object):
        pass

    class ListFileSharesInput(Mapping):
        pass

    class ListFileSharesOutput(Mapping):
        pass

    class ListGatewaysInput(Mapping):
        pass

    class ListGatewaysOutput(Mapping):
        pass

    class ListLocalDisksInput(Mapping):
        pass

    class ListLocalDisksOutput(Mapping):
        pass

    class ListTagsForResourceInput(Mapping):
        pass

    class ListTagsForResourceOutput(Mapping):
        pass

    class ListTapesInput(Mapping):
        pass

    class ListTapesOutput(Mapping):
        pass

    class ListVolumeInitiatorsInput(Mapping):
        pass

    class ListVolumeInitiatorsOutput(Mapping):
        pass

    class ListVolumeRecoveryPointsInput(Mapping):
        pass

    class ListVolumeRecoveryPointsOutput(Mapping):
        pass

    class ListVolumesInput(Mapping):
        pass

    class ListVolumesOutput(Mapping):
        pass

    class NotifyWhenUploadedInput(Mapping):
        pass

    class NotifyWhenUploadedOutput(Mapping):
        pass

    class RefreshCacheInput(Mapping):
        pass

    class RefreshCacheOutput(Mapping):
        pass

    class Folder(object):
        pass

    class RemoveTagsFromResourceInput(Mapping):
        pass

    class RemoveTagsFromResourceOutput(Mapping):
        pass

    class TagKey(object):
        pass

    class ResetCacheInput(Mapping):
        pass

    class ResetCacheOutput(Mapping):
        pass

    class RetrieveTapeArchiveInput(Mapping):
        pass

    class RetrieveTapeArchiveOutput(Mapping):
        pass

    class RetrieveTapeRecoveryPointInput(Mapping):
        pass

    class RetrieveTapeRecoveryPointOutput(Mapping):
        pass

    class SetLocalConsolePasswordInput(Mapping):
        pass

    class SetLocalConsolePasswordOutput(Mapping):
        pass

    class SetSMBGuestPasswordInput(Mapping):
        pass

    class SetSMBGuestPasswordOutput(Mapping):
        pass

    class ShutdownGatewayInput(Mapping):
        pass

    class ShutdownGatewayOutput(Mapping):
        pass

    class StartGatewayInput(Mapping):
        pass

    class StartGatewayOutput(Mapping):
        pass

    class UpdateBandwidthRateLimitInput(Mapping):
        pass

    class UpdateBandwidthRateLimitOutput(Mapping):
        pass

    class BandwidthUploadRateLimit(object):
        pass

    class BandwidthDownloadRateLimit(object):
        pass

    class UpdateChapCredentialsInput(Mapping):
        pass

    class UpdateChapCredentialsOutput(Mapping):
        pass

    class UpdateGatewayInformationInput(Mapping):
        pass

    class UpdateGatewayInformationOutput(Mapping):
        pass

    class UpdateGatewaySoftwareNowInput(Mapping):
        pass

    class UpdateGatewaySoftwareNowOutput(Mapping):
        pass

    class UpdateMaintenanceStartTimeInput(Mapping):
        pass

    class UpdateMaintenanceStartTimeOutput(Mapping):
        pass

    class UpdateNFSFileShareInput(Mapping):
        pass

    class UpdateNFSFileShareOutput(Mapping):
        pass

    class UpdateSMBFileShareInput(Mapping):
        pass

    class UpdateSMBFileShareOutput(Mapping):
        pass

    class UpdateSnapshotScheduleInput(Mapping):
        pass

    class UpdateSnapshotScheduleOutput(Mapping):
        pass

    class UpdateVTLDeviceTypeInput(Mapping):
        pass

    class UpdateVTLDeviceTypeOutput(Mapping):
        pass

    def activate_gateway(self, GatewayRegion: str, GatewayTimezone: str, GatewayName: str, ActivationKey: str, GatewayType: str=None, TapeDriveType: str=None, MediumChangerType: str=None) -> ActivateGatewayOutput:
        pass

    def add_cache(self, DiskIds: List[DiskId], GatewayARN: str) -> AddCacheOutput:
        pass

    def add_tags_to_resource(self, Tags: List[Tag], ResourceARN: str) -> AddTagsToResourceOutput:
        pass

    def add_upload_buffer(self, DiskIds: List[DiskId], GatewayARN: str) -> AddUploadBufferOutput:
        pass

    def add_working_storage(self, DiskIds: List[DiskId], GatewayARN: str) -> AddWorkingStorageOutput:
        pass

    def attach_volume(self, NetworkInterfaceId: str, VolumeARN: str, GatewayARN: str, TargetName: str=None, DiskId: str=None) -> AttachVolumeOutput:
        pass

    def cancel_archival(self, TapeARN: str, GatewayARN: str) -> CancelArchivalOutput:
        pass

    def cancel_retrieval(self, TapeARN: str, GatewayARN: str) -> CancelRetrievalOutput:
        pass

    def create_cached_iscsi_volume(self, ClientToken: str, NetworkInterfaceId: str, TargetName: str, VolumeSizeInBytes: long, GatewayARN: str, SnapshotId: str=None, SourceVolumeARN: str=None, KMSEncrypted: Boolean=None, KMSKey: str=None) -> CreateCachediSCSIVolumeOutput:
        pass

    def create_nfs_file_share(self, LocationARN: str, Role: str, GatewayARN: str, ClientToken: str, NFSFileShareDefaults: NFSFileShareDefaults=None, KMSEncrypted: Boolean=None, KMSKey: str=None, DefaultStorageClass: str=None, ObjectACL: str=None, ClientList: List[IPV4AddressCIDR]=None, Squash: str=None, ReadOnly: Boolean=None, GuessMIMETypeEnabled: Boolean=None, RequesterPays: Boolean=None) -> CreateNFSFileShareOutput:
        pass

    def create_smb_file_share(self, LocationARN: str, Role: str, GatewayARN: str, ClientToken: str, KMSEncrypted: Boolean=None, KMSKey: str=None, DefaultStorageClass: str=None, ObjectACL: str=None, ReadOnly: Boolean=None, GuessMIMETypeEnabled: Boolean=None, RequesterPays: Boolean=None, ValidUserList: List[FileShareUser]=None, InvalidUserList: List[FileShareUser]=None, Authentication: str=None) -> CreateSMBFileShareOutput:
        pass

    def create_snapshot(self, SnapshotDescription: str, VolumeARN: str) -> CreateSnapshotOutput:
        pass

    def create_snapshot_from_volume_recovery_point(self, SnapshotDescription: str, VolumeARN: str) -> CreateSnapshotFromVolumeRecoveryPointOutput:
        pass

    def create_stored_iscsi_volume(self, NetworkInterfaceId: str, TargetName: str, PreserveExistingData: boolean, DiskId: str, GatewayARN: str, SnapshotId: str=None, KMSEncrypted: Boolean=None, KMSKey: str=None) -> CreateStorediSCSIVolumeOutput:
        pass

    def create_tape_with_barcode(self, TapeBarcode: str, TapeSizeInBytes: TapeSize, GatewayARN: str, KMSEncrypted: Boolean=None, KMSKey: str=None) -> CreateTapeWithBarcodeOutput:
        pass

    def create_tapes(self, TapeBarcodePrefix: str, NumTapesToCreate: int, ClientToken: str, TapeSizeInBytes: TapeSize, GatewayARN: str, KMSEncrypted: Boolean=None, KMSKey: str=None) -> CreateTapesOutput:
        pass

    def delete_bandwidth_rate_limit(self, BandwidthType: str, GatewayARN: str) -> DeleteBandwidthRateLimitOutput:
        pass

    def delete_chap_credentials(self, InitiatorName: str, TargetARN: str) -> DeleteChapCredentialsOutput:
        pass

    def delete_file_share(self, FileShareARN: str, ForceDelete: boolean=None) -> DeleteFileShareOutput:
        pass

    def delete_gateway(self, GatewayARN: str) -> DeleteGatewayOutput:
        pass

    def delete_snapshot_schedule(self, VolumeARN: str) -> DeleteSnapshotScheduleOutput:
        pass

    def delete_tape(self, TapeARN: str, GatewayARN: str) -> DeleteTapeOutput:
        pass

    def delete_tape_archive(self, TapeARN: str) -> DeleteTapeArchiveOutput:
        pass

    def delete_volume(self, VolumeARN: str) -> DeleteVolumeOutput:
        pass

    def describe_bandwidth_rate_limit(self, GatewayARN: str) -> DescribeBandwidthRateLimitOutput:
        pass

    def describe_cache(self, GatewayARN: str) -> DescribeCacheOutput:
        pass

    def describe_cached_iscsi_volumes(self, VolumeARNs: List[VolumeARN]) -> DescribeCachediSCSIVolumesOutput:
        pass

    def describe_chap_credentials(self, TargetARN: str) -> DescribeChapCredentialsOutput:
        pass

    def describe_gateway_information(self, GatewayARN: str) -> DescribeGatewayInformationOutput:
        pass

    def describe_maintenance_start_time(self, GatewayARN: str) -> DescribeMaintenanceStartTimeOutput:
        pass

    def describe_nfs_file_shares(self, FileShareARNList: List[FileShareARN]) -> DescribeNFSFileSharesOutput:
        pass

    def describe_smb_file_shares(self, FileShareARNList: List[FileShareARN]) -> DescribeSMBFileSharesOutput:
        pass

    def describe_smb_settings(self, GatewayARN: str) -> DescribeSMBSettingsOutput:
        pass

    def describe_snapshot_schedule(self, VolumeARN: str) -> DescribeSnapshotScheduleOutput:
        pass

    def describe_stored_iscsi_volumes(self, VolumeARNs: List[VolumeARN]) -> DescribeStorediSCSIVolumesOutput:
        pass

    def describe_tape_archives(self, TapeARNs: List[TapeARN]=None, Marker: str=None, Limit: int=None) -> DescribeTapeArchivesOutput:
        pass

    def describe_tape_recovery_points(self, GatewayARN: str, Marker: str=None, Limit: int=None) -> DescribeTapeRecoveryPointsOutput:
        pass

    def describe_tapes(self, GatewayARN: str, TapeARNs: List[TapeARN]=None, Marker: str=None, Limit: int=None) -> DescribeTapesOutput:
        pass

    def describe_upload_buffer(self, GatewayARN: str) -> DescribeUploadBufferOutput:
        pass

    def describe_vtl_devices(self, GatewayARN: str, VTLDeviceARNs: List[VTLDeviceARN]=None, Marker: str=None, Limit: int=None) -> DescribeVTLDevicesOutput:
        pass

    def describe_working_storage(self, GatewayARN: str) -> DescribeWorkingStorageOutput:
        pass

    def detach_volume(self, VolumeARN: str, ForceDetach: Boolean=None) -> DetachVolumeOutput:
        pass

    def disable_gateway(self, GatewayARN: str) -> DisableGatewayOutput:
        pass

    def join_domain(self, Password: str, UserName: str, DomainName: str, GatewayARN: str, OrganizationalUnit: str=None, DomainControllers: List[Host]=None) -> JoinDomainOutput:
        pass

    def list_file_shares(self, GatewayARN: str=None, Limit: int=None, Marker: str=None) -> ListFileSharesOutput:
        pass

    def list_gateways(self, Marker: str=None, Limit: int=None) -> ListGatewaysOutput:
        pass

    def list_local_disks(self, GatewayARN: str) -> ListLocalDisksOutput:
        pass

    def list_tags_for_resource(self, ResourceARN: str, Marker: str=None, Limit: int=None) -> ListTagsForResourceOutput:
        pass

    def list_tapes(self, TapeARNs: List[TapeARN]=None, Marker: str=None, Limit: int=None) -> ListTapesOutput:
        pass

    def list_volume_initiators(self, VolumeARN: str) -> ListVolumeInitiatorsOutput:
        pass

    def list_volume_recovery_points(self, GatewayARN: str) -> ListVolumeRecoveryPointsOutput:
        pass

    def list_volumes(self, GatewayARN: str=None, Marker: str=None, Limit: int=None) -> ListVolumesOutput:
        pass

    def notify_when_uploaded(self, FileShareARN: str) -> NotifyWhenUploadedOutput:
        pass

    def refresh_cache(self, FileShareARN: str, FolderList: List[Folder]=None, Recursive: Boolean=None) -> RefreshCacheOutput:
        pass

    def remove_tags_from_resource(self, TagKeys: List[TagKey], ResourceARN: str) -> RemoveTagsFromResourceOutput:
        pass

    def reset_cache(self, GatewayARN: str) -> ResetCacheOutput:
        pass

    def retrieve_tape_archive(self, GatewayARN: str, TapeARN: str) -> RetrieveTapeArchiveOutput:
        pass

    def retrieve_tape_recovery_point(self, GatewayARN: str, TapeARN: str) -> RetrieveTapeRecoveryPointOutput:
        pass

    def set_local_console_password(self, LocalConsolePassword: str, GatewayARN: str) -> SetLocalConsolePasswordOutput:
        pass

    def set_smb_guest_password(self, Password: str, GatewayARN: str) -> SetSMBGuestPasswordOutput:
        pass

    def shutdown_gateway(self, GatewayARN: str) -> ShutdownGatewayOutput:
        pass

    def start_gateway(self, GatewayARN: str) -> StartGatewayOutput:
        pass

    def update_bandwidth_rate_limit(self, GatewayARN: str, AverageUploadRateLimitInBitsPerSec: BandwidthUploadRateLimit=None, AverageDownloadRateLimitInBitsPerSec: BandwidthDownloadRateLimit=None) -> UpdateBandwidthRateLimitOutput:
        pass

    def update_chap_credentials(self, InitiatorName: str, SecretToAuthenticateInitiator: str, TargetARN: str, SecretToAuthenticateTarget: str=None) -> UpdateChapCredentialsOutput:
        pass

    def update_gateway_information(self, GatewayARN: str, GatewayName: str=None, GatewayTimezone: str=None) -> UpdateGatewayInformationOutput:
        pass

    def update_gateway_software_now(self, GatewayARN: str) -> UpdateGatewaySoftwareNowOutput:
        pass

    def update_maintenance_start_time(self, DayOfWeek: int, MinuteOfHour: int, HourOfDay: int, GatewayARN: str) -> UpdateMaintenanceStartTimeOutput:
        pass

    def update_nfs_file_share(self, FileShareARN: str, KMSEncrypted: Boolean=None, KMSKey: str=None, NFSFileShareDefaults: NFSFileShareDefaults=None, DefaultStorageClass: str=None, ObjectACL: str=None, ClientList: List[IPV4AddressCIDR]=None, Squash: str=None, ReadOnly: Boolean=None, GuessMIMETypeEnabled: Boolean=None, RequesterPays: Boolean=None) -> UpdateNFSFileShareOutput:
        pass

    def update_smb_file_share(self, FileShareARN: str, KMSEncrypted: Boolean=None, KMSKey: str=None, DefaultStorageClass: str=None, ObjectACL: str=None, ReadOnly: Boolean=None, GuessMIMETypeEnabled: Boolean=None, RequesterPays: Boolean=None, ValidUserList: List[FileShareUser]=None, InvalidUserList: List[FileShareUser]=None) -> UpdateSMBFileShareOutput:
        pass

    def update_snapshot_schedule(self, RecurrenceInHours: int, StartAt: int, VolumeARN: str, Description: str=None) -> UpdateSnapshotScheduleOutput:
        pass

    def update_vtl_device_type(self, DeviceType: str, VTLDeviceARN: str) -> UpdateVTLDeviceTypeOutput:
        pass


class STS(BaseClient):
    class AssumeRoleRequest(Mapping):
        pass

    class AssumeRoleResponse(Mapping):
        pass

    class AssumeRoleWithSAMLRequest(Mapping):
        pass

    class AssumeRoleWithSAMLResponse(Mapping):
        pass

    class AssumeRoleWithWebIdentityRequest(Mapping):
        pass

    class AssumeRoleWithWebIdentityResponse(Mapping):
        pass

    class DecodeAuthorizationMessageRequest(Mapping):
        pass

    class DecodeAuthorizationMessageResponse(Mapping):
        pass

    class GetCallerIdentityRequest(Mapping):
        pass

    class GetCallerIdentityResponse(Mapping):
        pass

    class GetFederationTokenRequest(Mapping):
        pass

    class GetFederationTokenResponse(Mapping):
        pass

    class GetSessionTokenRequest(Mapping):
        pass

    class GetSessionTokenResponse(Mapping):
        pass

    def assume_role(self, RoleSessionName: str, RoleArn: str, Policy: str=None, DurationSeconds: int=None, ExternalId: str=None, SerialNumber: str=None, TokenCode: str=None) -> AssumeRoleResponse:
        pass

    def assume_role_with_saml(self, SAMLAssertion: str, PrincipalArn: str, RoleArn: str, Policy: str=None, DurationSeconds: int=None) -> AssumeRoleWithSAMLResponse:
        pass

    def assume_role_with_web_identity(self, WebIdentityToken: str, RoleSessionName: str, RoleArn: str, ProviderId: str=None, Policy: str=None, DurationSeconds: int=None) -> AssumeRoleWithWebIdentityResponse:
        pass

    def decode_authorization_message(self, EncodedMessage: str) -> DecodeAuthorizationMessageResponse:
        pass

    def get_caller_identity(self) -> GetCallerIdentityResponse:
        pass

    def get_federation_token(self, Name: str, Policy: str=None, DurationSeconds: int=None) -> GetFederationTokenResponse:
        pass

    def get_session_token(self, DurationSeconds: int=None, SerialNumber: str=None, TokenCode: str=None) -> GetSessionTokenResponse:
        pass


class Support(BaseClient):
    class AddAttachmentsToSetRequest(Mapping):
        pass

    class AddAttachmentsToSetResponse(Mapping):
        pass

    class Attachment(Mapping):
        pass

    class AddCommunicationToCaseRequest(Mapping):
        pass

    class AddCommunicationToCaseResponse(Mapping):
        pass

    class CcEmailAddress(object):
        pass

    class CreateCaseRequest(Mapping):
        pass

    class CreateCaseResponse(Mapping):
        pass

    class DescribeAttachmentRequest(Mapping):
        pass

    class DescribeAttachmentResponse(Mapping):
        pass

    class DescribeCasesRequest(Mapping):
        pass

    class DescribeCasesResponse(Mapping):
        pass

    class CaseId(object):
        pass

    class IncludeResolvedCases(object):
        pass

    class IncludeCommunications(object):
        pass

    class DescribeCommunicationsRequest(Mapping):
        pass

    class DescribeCommunicationsResponse(Mapping):
        pass

    class DescribeServicesRequest(Mapping):
        pass

    class DescribeServicesResponse(Mapping):
        pass

    class ServiceCode(object):
        pass

    class DescribeSeverityLevelsRequest(Mapping):
        pass

    class DescribeSeverityLevelsResponse(Mapping):
        pass

    class DescribeTrustedAdvisorCheckRefreshStatusesRequest(Mapping):
        pass

    class DescribeTrustedAdvisorCheckRefreshStatusesResponse(Mapping):
        pass

    class String(object):
        pass

    class DescribeTrustedAdvisorCheckResultRequest(Mapping):
        pass

    class DescribeTrustedAdvisorCheckResultResponse(Mapping):
        pass

    class DescribeTrustedAdvisorCheckSummariesRequest(Mapping):
        pass

    class DescribeTrustedAdvisorCheckSummariesResponse(Mapping):
        pass

    class DescribeTrustedAdvisorChecksRequest(Mapping):
        pass

    class DescribeTrustedAdvisorChecksResponse(Mapping):
        pass

    class RefreshTrustedAdvisorCheckRequest(Mapping):
        pass

    class RefreshTrustedAdvisorCheckResponse(Mapping):
        pass

    class ResolveCaseRequest(Mapping):
        pass

    class ResolveCaseResponse(Mapping):
        pass

    def add_attachments_to_set(self, attachments: List[Attachment], attachmentSetId: str=None) -> AddAttachmentsToSetResponse:
        pass

    def add_communication_to_case(self, communicationBody: str, caseId: str=None, ccEmailAddresses: List[CcEmailAddress]=None, attachmentSetId: str=None) -> AddCommunicationToCaseResponse:
        pass

    def create_case(self, communicationBody: str, subject: str, serviceCode: str=None, severityCode: str=None, categoryCode: str=None, ccEmailAddresses: List[CcEmailAddress]=None, language: str=None, issueType: str=None, attachmentSetId: str=None) -> CreateCaseResponse:
        pass

    def describe_attachment(self, attachmentId: str) -> DescribeAttachmentResponse:
        pass

    def describe_cases(self, caseIdList: List[CaseId]=None, displayId: str=None, afterTime: str=None, beforeTime: str=None, includeResolvedCases: IncludeResolvedCases=None, nextToken: str=None, maxResults: int=None, language: str=None, includeCommunications: IncludeCommunications=None) -> DescribeCasesResponse:
        pass

    def describe_communications(self, caseId: str, beforeTime: str=None, afterTime: str=None, nextToken: str=None, maxResults: int=None) -> DescribeCommunicationsResponse:
        pass

    def describe_services(self, serviceCodeList: List[ServiceCode]=None, language: str=None) -> DescribeServicesResponse:
        pass

    def describe_severity_levels(self, language: str=None) -> DescribeSeverityLevelsResponse:
        pass

    def describe_trusted_advisor_check_refresh_statuses(self, checkIds: List[String]) -> DescribeTrustedAdvisorCheckRefreshStatusesResponse:
        pass

    def describe_trusted_advisor_check_result(self, checkId: str, language: str=None) -> DescribeTrustedAdvisorCheckResultResponse:
        pass

    def describe_trusted_advisor_check_summaries(self, checkIds: List[String]) -> DescribeTrustedAdvisorCheckSummariesResponse:
        pass

    def describe_trusted_advisor_checks(self, language: str) -> DescribeTrustedAdvisorChecksResponse:
        pass

    def refresh_trusted_advisor_check(self, checkId: str) -> RefreshTrustedAdvisorCheckResponse:
        pass

    def resolve_case(self, caseId: str=None) -> ResolveCaseResponse:
        pass


class SWF(BaseClient):
    class CountClosedWorkflowExecutionsInput(Mapping):
        pass

    class WorkflowExecutionCount(Mapping):
        pass

    class ExecutionTimeFilter(Mapping):
        pass

    class WorkflowExecutionFilter(Mapping):
        pass

    class WorkflowTypeFilter(Mapping):
        pass

    class TagFilter(Mapping):
        pass

    class CloseStatusFilter(Mapping):
        pass

    class CountOpenWorkflowExecutionsInput(Mapping):
        pass

    class CountPendingActivityTasksInput(Mapping):
        pass

    class PendingTaskCount(Mapping):
        pass

    class TaskList(Mapping):
        pass

    class CountPendingDecisionTasksInput(Mapping):
        pass

    class DeprecateActivityTypeInput(Mapping):
        pass

    class ActivityType(Mapping):
        pass

    class DeprecateDomainInput(Mapping):
        pass

    class DeprecateWorkflowTypeInput(Mapping):
        pass

    class WorkflowType(Mapping):
        pass

    class DescribeActivityTypeInput(Mapping):
        pass

    class ActivityTypeDetail(Mapping):
        pass

    class DescribeDomainInput(Mapping):
        pass

    class DomainDetail(Mapping):
        pass

    class DescribeWorkflowExecutionInput(Mapping):
        pass

    class WorkflowExecutionDetail(Mapping):
        pass

    class WorkflowExecution(Mapping):
        pass

    class DescribeWorkflowTypeInput(Mapping):
        pass

    class WorkflowTypeDetail(Mapping):
        pass

    class GetWorkflowExecutionHistoryInput(Mapping):
        pass

    class History(Mapping):
        pass

    class ReverseOrder(object):
        pass

    class ListActivityTypesInput(Mapping):
        pass

    class ActivityTypeInfos(Mapping):
        pass

    class ListClosedWorkflowExecutionsInput(Mapping):
        pass

    class WorkflowExecutionInfos(Mapping):
        pass

    class ListDomainsInput(Mapping):
        pass

    class DomainInfos(Mapping):
        pass

    class ListOpenWorkflowExecutionsInput(Mapping):
        pass

    class ListWorkflowTypesInput(Mapping):
        pass

    class WorkflowTypeInfos(Mapping):
        pass

    class PollForActivityTaskInput(Mapping):
        pass

    class ActivityTask(Mapping):
        pass

    class PollForDecisionTaskInput(Mapping):
        pass

    class DecisionTask(Mapping):
        pass

    class RecordActivityTaskHeartbeatInput(Mapping):
        pass

    class ActivityTaskStatus(Mapping):
        pass

    class RegisterActivityTypeInput(Mapping):
        pass

    class RegisterDomainInput(Mapping):
        pass

    class RegisterWorkflowTypeInput(Mapping):
        pass

    class RequestCancelWorkflowExecutionInput(Mapping):
        pass

    class RespondActivityTaskCanceledInput(Mapping):
        pass

    class RespondActivityTaskCompletedInput(Mapping):
        pass

    class RespondActivityTaskFailedInput(Mapping):
        pass

    class RespondDecisionTaskCompletedInput(Mapping):
        pass

    class Decision(Mapping):
        pass

    class SignalWorkflowExecutionInput(Mapping):
        pass

    class StartWorkflowExecutionInput(Mapping):
        pass

    class Run(Mapping):
        pass

    class Tag(object):
        pass

    class TerminateWorkflowExecutionInput(Mapping):
        pass

    def count_closed_workflow_executions(self, domain: str, startTimeFilter: ExecutionTimeFilter=None, closeTimeFilter: ExecutionTimeFilter=None, executionFilter: WorkflowExecutionFilter=None, typeFilter: WorkflowTypeFilter=None, tagFilter: TagFilter=None, closeStatusFilter: CloseStatusFilter=None) -> WorkflowExecutionCount:
        pass

    def count_open_workflow_executions(self, startTimeFilter: ExecutionTimeFilter, domain: str, typeFilter: WorkflowTypeFilter=None, tagFilter: TagFilter=None, executionFilter: WorkflowExecutionFilter=None) -> WorkflowExecutionCount:
        pass

    def count_pending_activity_tasks(self, taskList: TaskList, domain: str) -> PendingTaskCount:
        pass

    def count_pending_decision_tasks(self, taskList: TaskList, domain: str) -> PendingTaskCount:
        pass

    def deprecate_activity_type(self, activityType: ActivityType, domain: str):
        pass

    def deprecate_domain(self, name: str):
        pass

    def deprecate_workflow_type(self, workflowType: WorkflowType, domain: str):
        pass

    def describe_activity_type(self, activityType: ActivityType, domain: str) -> ActivityTypeDetail:
        pass

    def describe_domain(self, name: str) -> DomainDetail:
        pass

    def describe_workflow_execution(self, execution: WorkflowExecution, domain: str) -> WorkflowExecutionDetail:
        pass

    def describe_workflow_type(self, workflowType: WorkflowType, domain: str) -> WorkflowTypeDetail:
        pass

    def get_workflow_execution_history(self, execution: WorkflowExecution, domain: str, nextPageToken: str=None, maximumPageSize: int=None, reverseOrder: ReverseOrder=None) -> History:
        pass

    def list_activity_types(self, registrationStatus: str, domain: str, name: str=None, nextPageToken: str=None, maximumPageSize: int=None, reverseOrder: ReverseOrder=None) -> ActivityTypeInfos:
        pass

    def list_closed_workflow_executions(self, domain: str, startTimeFilter: ExecutionTimeFilter=None, closeTimeFilter: ExecutionTimeFilter=None, executionFilter: WorkflowExecutionFilter=None, closeStatusFilter: CloseStatusFilter=None, typeFilter: WorkflowTypeFilter=None, tagFilter: TagFilter=None, nextPageToken: str=None, maximumPageSize: int=None, reverseOrder: ReverseOrder=None) -> WorkflowExecutionInfos:
        pass

    def list_domains(self, registrationStatus: str, nextPageToken: str=None, maximumPageSize: int=None, reverseOrder: ReverseOrder=None) -> DomainInfos:
        pass

    def list_open_workflow_executions(self, startTimeFilter: ExecutionTimeFilter, domain: str, typeFilter: WorkflowTypeFilter=None, tagFilter: TagFilter=None, nextPageToken: str=None, maximumPageSize: int=None, reverseOrder: ReverseOrder=None, executionFilter: WorkflowExecutionFilter=None) -> WorkflowExecutionInfos:
        pass

    def list_workflow_types(self, registrationStatus: str, domain: str, name: str=None, nextPageToken: str=None, maximumPageSize: int=None, reverseOrder: ReverseOrder=None) -> WorkflowTypeInfos:
        pass

    def poll_for_activity_task(self, taskList: TaskList, domain: str, identity: str=None) -> ActivityTask:
        pass

    def poll_for_decision_task(self, taskList: TaskList, domain: str, identity: str=None, nextPageToken: str=None, maximumPageSize: int=None, reverseOrder: ReverseOrder=None) -> DecisionTask:
        pass

    def record_activity_task_heartbeat(self, taskToken: str, details: str=None) -> ActivityTaskStatus:
        pass

    def register_activity_type(self, version: str, name: str, domain: str, description: str=None, defaultTaskStartToCloseTimeout: str=None, defaultTaskHeartbeatTimeout: str=None, defaultTaskList: TaskList=None, defaultTaskPriority: str=None, defaultTaskScheduleToStartTimeout: str=None, defaultTaskScheduleToCloseTimeout: str=None):
        pass

    def register_domain(self, workflowExecutionRetentionPeriodInDays: str, name: str, description: str=None):
        pass

    def register_workflow_type(self, version: str, name: str, domain: str, description: str=None, defaultTaskStartToCloseTimeout: str=None, defaultExecutionStartToCloseTimeout: str=None, defaultTaskList: TaskList=None, defaultTaskPriority: str=None, defaultChildPolicy: str=None, defaultLambdaRole: str=None):
        pass

    def request_cancel_workflow_execution(self, workflowId: str, domain: str, runId: str=None):
        pass

    def respond_activity_task_canceled(self, taskToken: str, details: str=None):
        pass

    def respond_activity_task_completed(self, taskToken: str, result: str=None):
        pass

    def respond_activity_task_failed(self, taskToken: str, reason: str=None, details: str=None):
        pass

    def respond_decision_task_completed(self, taskToken: str, decisions: List[Decision]=None, executionContext: str=None):
        pass

    def signal_workflow_execution(self, signalName: str, workflowId: str, domain: str, runId: str=None, input: str=None):
        pass

    def start_workflow_execution(self, workflowType: WorkflowType, workflowId: str, domain: str, taskList: TaskList=None, taskPriority: str=None, input: str=None, executionStartToCloseTimeout: str=None, tagList: List[Tag]=None, taskStartToCloseTimeout: str=None, childPolicy: str=None, lambdaRole: str=None) -> Run:
        pass

    def terminate_workflow_execution(self, workflowId: str, domain: str, runId: str=None, reason: str=None, details: str=None, childPolicy: str=None):
        pass


class TranscribeService(BaseClient):
    class CreateVocabularyRequest(Mapping):
        pass

    class CreateVocabularyResponse(Mapping):
        pass

    class Phrase(object):
        pass

    class DeleteTranscriptionJobRequest(Mapping):
        pass

    class DeleteVocabularyRequest(Mapping):
        pass

    class GetTranscriptionJobRequest(Mapping):
        pass

    class GetTranscriptionJobResponse(Mapping):
        pass

    class GetVocabularyRequest(Mapping):
        pass

    class GetVocabularyResponse(Mapping):
        pass

    class ListTranscriptionJobsRequest(Mapping):
        pass

    class ListTranscriptionJobsResponse(Mapping):
        pass

    class ListVocabulariesRequest(Mapping):
        pass

    class ListVocabulariesResponse(Mapping):
        pass

    class StartTranscriptionJobRequest(Mapping):
        pass

    class StartTranscriptionJobResponse(Mapping):
        pass

    class Media(Mapping):
        pass

    class Settings(Mapping):
        pass

    class UpdateVocabularyRequest(Mapping):
        pass

    class UpdateVocabularyResponse(Mapping):
        pass

    def create_vocabulary(self, Phrases: List[Phrase], LanguageCode: str, VocabularyName: str) -> CreateVocabularyResponse:
        pass

    def delete_transcription_job(self, TranscriptionJobName: str):
        pass

    def delete_vocabulary(self, VocabularyName: str):
        pass

    def get_transcription_job(self, TranscriptionJobName: str) -> GetTranscriptionJobResponse:
        pass

    def get_vocabulary(self, VocabularyName: str) -> GetVocabularyResponse:
        pass

    def list_transcription_jobs(self, Status: str=None, JobNameContains: str=None, NextToken: str=None, MaxResults: int=None) -> ListTranscriptionJobsResponse:
        pass

    def list_vocabularies(self, NextToken: str=None, MaxResults: int=None, StateEquals: str=None, NameContains: str=None) -> ListVocabulariesResponse:
        pass

    def start_transcription_job(self, Media: Media, MediaFormat: str, LanguageCode: str, TranscriptionJobName: str, MediaSampleRateHertz: int=None, OutputBucketName: str=None, Settings: Settings=None) -> StartTranscriptionJobResponse:
        pass

    def update_vocabulary(self, Phrases: List[Phrase], LanguageCode: str, VocabularyName: str) -> UpdateVocabularyResponse:
        pass


class Transfer(BaseClient):
    class CreateServerRequest(Mapping):
        pass

    class CreateServerResponse(Mapping):
        pass

    class IdentityProviderDetails(Mapping):
        pass

    class Tag(Mapping):
        pass

    class CreateUserRequest(Mapping):
        pass

    class CreateUserResponse(Mapping):
        pass

    class DeleteServerRequest(Mapping):
        pass

    class DeleteSshPublicKeyRequest(Mapping):
        pass

    class DeleteUserRequest(Mapping):
        pass

    class DescribeServerRequest(Mapping):
        pass

    class DescribeServerResponse(Mapping):
        pass

    class DescribeUserRequest(Mapping):
        pass

    class DescribeUserResponse(Mapping):
        pass

    class ImportSshPublicKeyRequest(Mapping):
        pass

    class ImportSshPublicKeyResponse(Mapping):
        pass

    class ListServersRequest(Mapping):
        pass

    class ListServersResponse(Mapping):
        pass

    class ListTagsForResourceRequest(Mapping):
        pass

    class ListTagsForResourceResponse(Mapping):
        pass

    class ListUsersRequest(Mapping):
        pass

    class ListUsersResponse(Mapping):
        pass

    class StartServerRequest(Mapping):
        pass

    class StopServerRequest(Mapping):
        pass

    class TagResourceRequest(Mapping):
        pass

    class TestIdentityProviderRequest(Mapping):
        pass

    class TestIdentityProviderResponse(Mapping):
        pass

    class UntagResourceRequest(Mapping):
        pass

    class TagKey(object):
        pass

    class UpdateServerRequest(Mapping):
        pass

    class UpdateServerResponse(Mapping):
        pass

    class UpdateUserRequest(Mapping):
        pass

    class UpdateUserResponse(Mapping):
        pass

    def create_server(self, IdentityProviderDetails: IdentityProviderDetails=None, IdentityProviderType: str=None, LoggingRole: str=None, Tags: List[Tag]=None) -> CreateServerResponse:
        pass

    def create_user(self, UserName: str, ServerId: str, Role: str, HomeDirectory: str=None, Policy: str=None, SshPublicKeyBody: str=None, Tags: List[Tag]=None) -> CreateUserResponse:
        pass

    def delete_server(self, ServerId: str):
        pass

    def delete_ssh_public_key(self, UserName: str, SshPublicKeyId: str, ServerId: str):
        pass

    def delete_user(self, UserName: str, ServerId: str):
        pass

    def describe_server(self, ServerId: str) -> DescribeServerResponse:
        pass

    def describe_user(self, UserName: str, ServerId: str) -> DescribeUserResponse:
        pass

    def import_ssh_public_key(self, UserName: str, SshPublicKeyBody: str, ServerId: str) -> ImportSshPublicKeyResponse:
        pass

    def list_servers(self, MaxResults: int=None, NextToken: str=None) -> ListServersResponse:
        pass

    def list_tags_for_resource(self, Arn: str, MaxResults: int=None, NextToken: str=None) -> ListTagsForResourceResponse:
        pass

    def list_users(self, ServerId: str, MaxResults: int=None, NextToken: str=None) -> ListUsersResponse:
        pass

    def start_server(self, ServerId: str):
        pass

    def stop_server(self, ServerId: str):
        pass

    def tag_resource(self, Tags: List[Tag], Arn: str):
        pass

    def test_identity_provider(self, UserName: str, ServerId: str, UserPassword: str=None) -> TestIdentityProviderResponse:
        pass

    def untag_resource(self, TagKeys: List[TagKey], Arn: str):
        pass

    def update_server(self, ServerId: str, IdentityProviderDetails: IdentityProviderDetails=None, LoggingRole: str=None) -> UpdateServerResponse:
        pass

    def update_user(self, UserName: str, ServerId: str, HomeDirectory: str=None, Policy: str=None, Role: str=None) -> UpdateUserResponse:
        pass


class Translate(BaseClient):
    class DeleteTerminologyRequest(Mapping):
        pass

    class GetTerminologyRequest(Mapping):
        pass

    class GetTerminologyResponse(Mapping):
        pass

    class ImportTerminologyRequest(Mapping):
        pass

    class ImportTerminologyResponse(Mapping):
        pass

    class TerminologyData(Mapping):
        pass

    class EncryptionKey(Mapping):
        pass

    class ListTerminologiesRequest(Mapping):
        pass

    class ListTerminologiesResponse(Mapping):
        pass

    class TranslateTextRequest(Mapping):
        pass

    class TranslateTextResponse(Mapping):
        pass

    class ResourceName(object):
        pass

    def delete_terminology(self, Name: str):
        pass

    def get_terminology(self, TerminologyDataFormat: str, Name: str) -> GetTerminologyResponse:
        pass

    def import_terminology(self, TerminologyData: TerminologyData, MergeStrategy: str, Name: str, Description: str=None, EncryptionKey: EncryptionKey=None) -> ImportTerminologyResponse:
        pass

    def list_terminologies(self, NextToken: str=None, MaxResults: int=None) -> ListTerminologiesResponse:
        pass

    def translate_text(self, TargetLanguageCode: str, SourceLanguageCode: str, Text: str, TerminologyNames: List[ResourceName]=None) -> TranslateTextResponse:
        pass


class WAF(BaseClient):
    class CreateByteMatchSetRequest(Mapping):
        pass

    class CreateByteMatchSetResponse(Mapping):
        pass

    class CreateGeoMatchSetRequest(Mapping):
        pass

    class CreateGeoMatchSetResponse(Mapping):
        pass

    class CreateIPSetRequest(Mapping):
        pass

    class CreateIPSetResponse(Mapping):
        pass

    class CreateRateBasedRuleRequest(Mapping):
        pass

    class CreateRateBasedRuleResponse(Mapping):
        pass

    class RateLimit(object):
        pass

    class CreateRegexMatchSetRequest(Mapping):
        pass

    class CreateRegexMatchSetResponse(Mapping):
        pass

    class CreateRegexPatternSetRequest(Mapping):
        pass

    class CreateRegexPatternSetResponse(Mapping):
        pass

    class CreateRuleRequest(Mapping):
        pass

    class CreateRuleResponse(Mapping):
        pass

    class CreateRuleGroupRequest(Mapping):
        pass

    class CreateRuleGroupResponse(Mapping):
        pass

    class CreateSizeConstraintSetRequest(Mapping):
        pass

    class CreateSizeConstraintSetResponse(Mapping):
        pass

    class CreateSqlInjectionMatchSetRequest(Mapping):
        pass

    class CreateSqlInjectionMatchSetResponse(Mapping):
        pass

    class CreateWebACLRequest(Mapping):
        pass

    class CreateWebACLResponse(Mapping):
        pass

    class WafAction(Mapping):
        pass

    class CreateXssMatchSetRequest(Mapping):
        pass

    class CreateXssMatchSetResponse(Mapping):
        pass

    class DeleteByteMatchSetRequest(Mapping):
        pass

    class DeleteByteMatchSetResponse(Mapping):
        pass

    class DeleteGeoMatchSetRequest(Mapping):
        pass

    class DeleteGeoMatchSetResponse(Mapping):
        pass

    class DeleteIPSetRequest(Mapping):
        pass

    class DeleteIPSetResponse(Mapping):
        pass

    class DeleteLoggingConfigurationRequest(Mapping):
        pass

    class DeleteLoggingConfigurationResponse(Mapping):
        pass

    class DeletePermissionPolicyRequest(Mapping):
        pass

    class DeletePermissionPolicyResponse(Mapping):
        pass

    class DeleteRateBasedRuleRequest(Mapping):
        pass

    class DeleteRateBasedRuleResponse(Mapping):
        pass

    class DeleteRegexMatchSetRequest(Mapping):
        pass

    class DeleteRegexMatchSetResponse(Mapping):
        pass

    class DeleteRegexPatternSetRequest(Mapping):
        pass

    class DeleteRegexPatternSetResponse(Mapping):
        pass

    class DeleteRuleRequest(Mapping):
        pass

    class DeleteRuleResponse(Mapping):
        pass

    class DeleteRuleGroupRequest(Mapping):
        pass

    class DeleteRuleGroupResponse(Mapping):
        pass

    class DeleteSizeConstraintSetRequest(Mapping):
        pass

    class DeleteSizeConstraintSetResponse(Mapping):
        pass

    class DeleteSqlInjectionMatchSetRequest(Mapping):
        pass

    class DeleteSqlInjectionMatchSetResponse(Mapping):
        pass

    class DeleteWebACLRequest(Mapping):
        pass

    class DeleteWebACLResponse(Mapping):
        pass

    class DeleteXssMatchSetRequest(Mapping):
        pass

    class DeleteXssMatchSetResponse(Mapping):
        pass

    class GetByteMatchSetRequest(Mapping):
        pass

    class GetByteMatchSetResponse(Mapping):
        pass

    class GetChangeTokenRequest(Mapping):
        pass

    class GetChangeTokenResponse(Mapping):
        pass

    class GetChangeTokenStatusRequest(Mapping):
        pass

    class GetChangeTokenStatusResponse(Mapping):
        pass

    class GetGeoMatchSetRequest(Mapping):
        pass

    class GetGeoMatchSetResponse(Mapping):
        pass

    class GetIPSetRequest(Mapping):
        pass

    class GetIPSetResponse(Mapping):
        pass

    class GetLoggingConfigurationRequest(Mapping):
        pass

    class GetLoggingConfigurationResponse(Mapping):
        pass

    class GetPermissionPolicyRequest(Mapping):
        pass

    class GetPermissionPolicyResponse(Mapping):
        pass

    class GetRateBasedRuleRequest(Mapping):
        pass

    class GetRateBasedRuleResponse(Mapping):
        pass

    class GetRateBasedRuleManagedKeysRequest(Mapping):
        pass

    class GetRateBasedRuleManagedKeysResponse(Mapping):
        pass

    class GetRegexMatchSetRequest(Mapping):
        pass

    class GetRegexMatchSetResponse(Mapping):
        pass

    class GetRegexPatternSetRequest(Mapping):
        pass

    class GetRegexPatternSetResponse(Mapping):
        pass

    class GetRuleRequest(Mapping):
        pass

    class GetRuleResponse(Mapping):
        pass

    class GetRuleGroupRequest(Mapping):
        pass

    class GetRuleGroupResponse(Mapping):
        pass

    class GetSampledRequestsRequest(Mapping):
        pass

    class GetSampledRequestsResponse(Mapping):
        pass

    class TimeWindow(Mapping):
        pass

    class GetSampledRequestsMaxItems(object):
        pass

    class GetSizeConstraintSetRequest(Mapping):
        pass

    class GetSizeConstraintSetResponse(Mapping):
        pass

    class GetSqlInjectionMatchSetRequest(Mapping):
        pass

    class GetSqlInjectionMatchSetResponse(Mapping):
        pass

    class GetWebACLRequest(Mapping):
        pass

    class GetWebACLResponse(Mapping):
        pass

    class GetXssMatchSetRequest(Mapping):
        pass

    class GetXssMatchSetResponse(Mapping):
        pass

    class ListActivatedRulesInRuleGroupRequest(Mapping):
        pass

    class ListActivatedRulesInRuleGroupResponse(Mapping):
        pass

    class ListByteMatchSetsRequest(Mapping):
        pass

    class ListByteMatchSetsResponse(Mapping):
        pass

    class ListGeoMatchSetsRequest(Mapping):
        pass

    class ListGeoMatchSetsResponse(Mapping):
        pass

    class ListIPSetsRequest(Mapping):
        pass

    class ListIPSetsResponse(Mapping):
        pass

    class ListLoggingConfigurationsRequest(Mapping):
        pass

    class ListLoggingConfigurationsResponse(Mapping):
        pass

    class ListRateBasedRulesRequest(Mapping):
        pass

    class ListRateBasedRulesResponse(Mapping):
        pass

    class ListRegexMatchSetsRequest(Mapping):
        pass

    class ListRegexMatchSetsResponse(Mapping):
        pass

    class ListRegexPatternSetsRequest(Mapping):
        pass

    class ListRegexPatternSetsResponse(Mapping):
        pass

    class ListRuleGroupsRequest(Mapping):
        pass

    class ListRuleGroupsResponse(Mapping):
        pass

    class ListRulesRequest(Mapping):
        pass

    class ListRulesResponse(Mapping):
        pass

    class ListSizeConstraintSetsRequest(Mapping):
        pass

    class ListSizeConstraintSetsResponse(Mapping):
        pass

    class ListSqlInjectionMatchSetsRequest(Mapping):
        pass

    class ListSqlInjectionMatchSetsResponse(Mapping):
        pass

    class ListSubscribedRuleGroupsRequest(Mapping):
        pass

    class ListSubscribedRuleGroupsResponse(Mapping):
        pass

    class ListWebACLsRequest(Mapping):
        pass

    class ListWebACLsResponse(Mapping):
        pass

    class ListXssMatchSetsRequest(Mapping):
        pass

    class ListXssMatchSetsResponse(Mapping):
        pass

    class PutLoggingConfigurationRequest(Mapping):
        pass

    class PutLoggingConfigurationResponse(Mapping):
        pass

    class LoggingConfiguration(Mapping):
        pass

    class PutPermissionPolicyRequest(Mapping):
        pass

    class PutPermissionPolicyResponse(Mapping):
        pass

    class UpdateByteMatchSetRequest(Mapping):
        pass

    class UpdateByteMatchSetResponse(Mapping):
        pass

    class ByteMatchSetUpdate(Mapping):
        pass

    class UpdateGeoMatchSetRequest(Mapping):
        pass

    class UpdateGeoMatchSetResponse(Mapping):
        pass

    class GeoMatchSetUpdate(Mapping):
        pass

    class UpdateIPSetRequest(Mapping):
        pass

    class UpdateIPSetResponse(Mapping):
        pass

    class IPSetUpdate(Mapping):
        pass

    class UpdateRateBasedRuleRequest(Mapping):
        pass

    class UpdateRateBasedRuleResponse(Mapping):
        pass

    class RuleUpdate(Mapping):
        pass

    class UpdateRegexMatchSetRequest(Mapping):
        pass

    class UpdateRegexMatchSetResponse(Mapping):
        pass

    class RegexMatchSetUpdate(Mapping):
        pass

    class UpdateRegexPatternSetRequest(Mapping):
        pass

    class UpdateRegexPatternSetResponse(Mapping):
        pass

    class RegexPatternSetUpdate(Mapping):
        pass

    class UpdateRuleRequest(Mapping):
        pass

    class UpdateRuleResponse(Mapping):
        pass

    class UpdateRuleGroupRequest(Mapping):
        pass

    class UpdateRuleGroupResponse(Mapping):
        pass

    class RuleGroupUpdate(Mapping):
        pass

    class UpdateSizeConstraintSetRequest(Mapping):
        pass

    class UpdateSizeConstraintSetResponse(Mapping):
        pass

    class SizeConstraintSetUpdate(Mapping):
        pass

    class UpdateSqlInjectionMatchSetRequest(Mapping):
        pass

    class UpdateSqlInjectionMatchSetResponse(Mapping):
        pass

    class SqlInjectionMatchSetUpdate(Mapping):
        pass

    class UpdateWebACLRequest(Mapping):
        pass

    class UpdateWebACLResponse(Mapping):
        pass

    class WebACLUpdate(Mapping):
        pass

    class UpdateXssMatchSetRequest(Mapping):
        pass

    class UpdateXssMatchSetResponse(Mapping):
        pass

    class XssMatchSetUpdate(Mapping):
        pass

    def create_byte_match_set(self, ChangeToken: str, Name: str) -> CreateByteMatchSetResponse:
        pass

    def create_geo_match_set(self, ChangeToken: str, Name: str) -> CreateGeoMatchSetResponse:
        pass

    def create_ip_set(self, ChangeToken: str, Name: str) -> CreateIPSetResponse:
        pass

    def create_rate_based_rule(self, ChangeToken: str, RateLimit: RateLimit, RateKey: str, MetricName: str, Name: str) -> CreateRateBasedRuleResponse:
        pass

    def create_regex_match_set(self, ChangeToken: str, Name: str) -> CreateRegexMatchSetResponse:
        pass

    def create_regex_pattern_set(self, ChangeToken: str, Name: str) -> CreateRegexPatternSetResponse:
        pass

    def create_rule(self, ChangeToken: str, MetricName: str, Name: str) -> CreateRuleResponse:
        pass

    def create_rule_group(self, ChangeToken: str, MetricName: str, Name: str) -> CreateRuleGroupResponse:
        pass

    def create_size_constraint_set(self, ChangeToken: str, Name: str) -> CreateSizeConstraintSetResponse:
        pass

    def create_sql_injection_match_set(self, ChangeToken: str, Name: str) -> CreateSqlInjectionMatchSetResponse:
        pass

    def create_web_acl(self, ChangeToken: str, DefaultAction: WafAction, MetricName: str, Name: str) -> CreateWebACLResponse:
        pass

    def create_xss_match_set(self, ChangeToken: str, Name: str) -> CreateXssMatchSetResponse:
        pass

    def delete_byte_match_set(self, ChangeToken: str, ByteMatchSetId: str) -> DeleteByteMatchSetResponse:
        pass

    def delete_geo_match_set(self, ChangeToken: str, GeoMatchSetId: str) -> DeleteGeoMatchSetResponse:
        pass

    def delete_ip_set(self, ChangeToken: str, IPSetId: str) -> DeleteIPSetResponse:
        pass

    def delete_logging_configuration(self, ResourceArn: str) -> DeleteLoggingConfigurationResponse:
        pass

    def delete_permission_policy(self, ResourceArn: str) -> DeletePermissionPolicyResponse:
        pass

    def delete_rate_based_rule(self, ChangeToken: str, RuleId: str) -> DeleteRateBasedRuleResponse:
        pass

    def delete_regex_match_set(self, ChangeToken: str, RegexMatchSetId: str) -> DeleteRegexMatchSetResponse:
        pass

    def delete_regex_pattern_set(self, ChangeToken: str, RegexPatternSetId: str) -> DeleteRegexPatternSetResponse:
        pass

    def delete_rule(self, ChangeToken: str, RuleId: str) -> DeleteRuleResponse:
        pass

    def delete_rule_group(self, ChangeToken: str, RuleGroupId: str) -> DeleteRuleGroupResponse:
        pass

    def delete_size_constraint_set(self, ChangeToken: str, SizeConstraintSetId: str) -> DeleteSizeConstraintSetResponse:
        pass

    def delete_sql_injection_match_set(self, ChangeToken: str, SqlInjectionMatchSetId: str) -> DeleteSqlInjectionMatchSetResponse:
        pass

    def delete_web_acl(self, ChangeToken: str, WebACLId: str) -> DeleteWebACLResponse:
        pass

    def delete_xss_match_set(self, ChangeToken: str, XssMatchSetId: str) -> DeleteXssMatchSetResponse:
        pass

    def get_byte_match_set(self, ByteMatchSetId: str) -> GetByteMatchSetResponse:
        pass

    def get_change_token(self) -> GetChangeTokenResponse:
        pass

    def get_change_token_status(self, ChangeToken: str) -> GetChangeTokenStatusResponse:
        pass

    def get_geo_match_set(self, GeoMatchSetId: str) -> GetGeoMatchSetResponse:
        pass

    def get_ip_set(self, IPSetId: str) -> GetIPSetResponse:
        pass

    def get_logging_configuration(self, ResourceArn: str) -> GetLoggingConfigurationResponse:
        pass

    def get_permission_policy(self, ResourceArn: str) -> GetPermissionPolicyResponse:
        pass

    def get_rate_based_rule(self, RuleId: str) -> GetRateBasedRuleResponse:
        pass

    def get_rate_based_rule_managed_keys(self, RuleId: str, NextMarker: str=None) -> GetRateBasedRuleManagedKeysResponse:
        pass

    def get_regex_match_set(self, RegexMatchSetId: str) -> GetRegexMatchSetResponse:
        pass

    def get_regex_pattern_set(self, RegexPatternSetId: str) -> GetRegexPatternSetResponse:
        pass

    def get_rule(self, RuleId: str) -> GetRuleResponse:
        pass

    def get_rule_group(self, RuleGroupId: str) -> GetRuleGroupResponse:
        pass

    def get_sampled_requests(self, MaxItems: GetSampledRequestsMaxItems, TimeWindow: TimeWindow, RuleId: str, WebAclId: str) -> GetSampledRequestsResponse:
        pass

    def get_size_constraint_set(self, SizeConstraintSetId: str) -> GetSizeConstraintSetResponse:
        pass

    def get_sql_injection_match_set(self, SqlInjectionMatchSetId: str) -> GetSqlInjectionMatchSetResponse:
        pass

    def get_web_acl(self, WebACLId: str) -> GetWebACLResponse:
        pass

    def get_xss_match_set(self, XssMatchSetId: str) -> GetXssMatchSetResponse:
        pass

    def list_activated_rules_in_rule_group(self, RuleGroupId: str=None, NextMarker: str=None, Limit: int=None) -> ListActivatedRulesInRuleGroupResponse:
        pass

    def list_byte_match_sets(self, NextMarker: str=None, Limit: int=None) -> ListByteMatchSetsResponse:
        pass

    def list_geo_match_sets(self, NextMarker: str=None, Limit: int=None) -> ListGeoMatchSetsResponse:
        pass

    def list_ip_sets(self, NextMarker: str=None, Limit: int=None) -> ListIPSetsResponse:
        pass

    def list_logging_configurations(self, NextMarker: str=None, Limit: int=None) -> ListLoggingConfigurationsResponse:
        pass

    def list_rate_based_rules(self, NextMarker: str=None, Limit: int=None) -> ListRateBasedRulesResponse:
        pass

    def list_regex_match_sets(self, NextMarker: str=None, Limit: int=None) -> ListRegexMatchSetsResponse:
        pass

    def list_regex_pattern_sets(self, NextMarker: str=None, Limit: int=None) -> ListRegexPatternSetsResponse:
        pass

    def list_rule_groups(self, NextMarker: str=None, Limit: int=None) -> ListRuleGroupsResponse:
        pass

    def list_rules(self, NextMarker: str=None, Limit: int=None) -> ListRulesResponse:
        pass

    def list_size_constraint_sets(self, NextMarker: str=None, Limit: int=None) -> ListSizeConstraintSetsResponse:
        pass

    def list_sql_injection_match_sets(self, NextMarker: str=None, Limit: int=None) -> ListSqlInjectionMatchSetsResponse:
        pass

    def list_subscribed_rule_groups(self, NextMarker: str=None, Limit: int=None) -> ListSubscribedRuleGroupsResponse:
        pass

    def list_web_acls(self, NextMarker: str=None, Limit: int=None) -> ListWebACLsResponse:
        pass

    def list_xss_match_sets(self, NextMarker: str=None, Limit: int=None) -> ListXssMatchSetsResponse:
        pass

    def put_logging_configuration(self, LoggingConfiguration: LoggingConfiguration) -> PutLoggingConfigurationResponse:
        pass

    def put_permission_policy(self, Policy: str, ResourceArn: str) -> PutPermissionPolicyResponse:
        pass

    def update_byte_match_set(self, Updates: List[ByteMatchSetUpdate], ChangeToken: str, ByteMatchSetId: str) -> UpdateByteMatchSetResponse:
        pass

    def update_geo_match_set(self, Updates: List[GeoMatchSetUpdate], ChangeToken: str, GeoMatchSetId: str) -> UpdateGeoMatchSetResponse:
        pass

    def update_ip_set(self, Updates: List[IPSetUpdate], ChangeToken: str, IPSetId: str) -> UpdateIPSetResponse:
        pass

    def update_rate_based_rule(self, RateLimit: RateLimit, Updates: List[RuleUpdate], ChangeToken: str, RuleId: str) -> UpdateRateBasedRuleResponse:
        pass

    def update_regex_match_set(self, ChangeToken: str, Updates: List[RegexMatchSetUpdate], RegexMatchSetId: str) -> UpdateRegexMatchSetResponse:
        pass

    def update_regex_pattern_set(self, ChangeToken: str, Updates: List[RegexPatternSetUpdate], RegexPatternSetId: str) -> UpdateRegexPatternSetResponse:
        pass

    def update_rule(self, Updates: List[RuleUpdate], ChangeToken: str, RuleId: str) -> UpdateRuleResponse:
        pass

    def update_rule_group(self, ChangeToken: str, Updates: List[RuleGroupUpdate], RuleGroupId: str) -> UpdateRuleGroupResponse:
        pass

    def update_size_constraint_set(self, Updates: List[SizeConstraintSetUpdate], ChangeToken: str, SizeConstraintSetId: str) -> UpdateSizeConstraintSetResponse:
        pass

    def update_sql_injection_match_set(self, Updates: List[SqlInjectionMatchSetUpdate], ChangeToken: str, SqlInjectionMatchSetId: str) -> UpdateSqlInjectionMatchSetResponse:
        pass

    def update_web_acl(self, ChangeToken: str, WebACLId: str, Updates: List[WebACLUpdate]=None, DefaultAction: WafAction=None) -> UpdateWebACLResponse:
        pass

    def update_xss_match_set(self, Updates: List[XssMatchSetUpdate], ChangeToken: str, XssMatchSetId: str) -> UpdateXssMatchSetResponse:
        pass


class WAFRegional(BaseClient):
    class AssociateWebACLRequest(Mapping):
        pass

    class AssociateWebACLResponse(Mapping):
        pass

    class CreateByteMatchSetRequest(Mapping):
        pass

    class CreateByteMatchSetResponse(Mapping):
        pass

    class CreateGeoMatchSetRequest(Mapping):
        pass

    class CreateGeoMatchSetResponse(Mapping):
        pass

    class CreateIPSetRequest(Mapping):
        pass

    class CreateIPSetResponse(Mapping):
        pass

    class CreateRateBasedRuleRequest(Mapping):
        pass

    class CreateRateBasedRuleResponse(Mapping):
        pass

    class RateLimit(object):
        pass

    class CreateRegexMatchSetRequest(Mapping):
        pass

    class CreateRegexMatchSetResponse(Mapping):
        pass

    class CreateRegexPatternSetRequest(Mapping):
        pass

    class CreateRegexPatternSetResponse(Mapping):
        pass

    class CreateRuleRequest(Mapping):
        pass

    class CreateRuleResponse(Mapping):
        pass

    class CreateRuleGroupRequest(Mapping):
        pass

    class CreateRuleGroupResponse(Mapping):
        pass

    class CreateSizeConstraintSetRequest(Mapping):
        pass

    class CreateSizeConstraintSetResponse(Mapping):
        pass

    class CreateSqlInjectionMatchSetRequest(Mapping):
        pass

    class CreateSqlInjectionMatchSetResponse(Mapping):
        pass

    class CreateWebACLRequest(Mapping):
        pass

    class CreateWebACLResponse(Mapping):
        pass

    class WafAction(Mapping):
        pass

    class CreateXssMatchSetRequest(Mapping):
        pass

    class CreateXssMatchSetResponse(Mapping):
        pass

    class DeleteByteMatchSetRequest(Mapping):
        pass

    class DeleteByteMatchSetResponse(Mapping):
        pass

    class DeleteGeoMatchSetRequest(Mapping):
        pass

    class DeleteGeoMatchSetResponse(Mapping):
        pass

    class DeleteIPSetRequest(Mapping):
        pass

    class DeleteIPSetResponse(Mapping):
        pass

    class DeleteLoggingConfigurationRequest(Mapping):
        pass

    class DeleteLoggingConfigurationResponse(Mapping):
        pass

    class DeletePermissionPolicyRequest(Mapping):
        pass

    class DeletePermissionPolicyResponse(Mapping):
        pass

    class DeleteRateBasedRuleRequest(Mapping):
        pass

    class DeleteRateBasedRuleResponse(Mapping):
        pass

    class DeleteRegexMatchSetRequest(Mapping):
        pass

    class DeleteRegexMatchSetResponse(Mapping):
        pass

    class DeleteRegexPatternSetRequest(Mapping):
        pass

    class DeleteRegexPatternSetResponse(Mapping):
        pass

    class DeleteRuleRequest(Mapping):
        pass

    class DeleteRuleResponse(Mapping):
        pass

    class DeleteRuleGroupRequest(Mapping):
        pass

    class DeleteRuleGroupResponse(Mapping):
        pass

    class DeleteSizeConstraintSetRequest(Mapping):
        pass

    class DeleteSizeConstraintSetResponse(Mapping):
        pass

    class DeleteSqlInjectionMatchSetRequest(Mapping):
        pass

    class DeleteSqlInjectionMatchSetResponse(Mapping):
        pass

    class DeleteWebACLRequest(Mapping):
        pass

    class DeleteWebACLResponse(Mapping):
        pass

    class DeleteXssMatchSetRequest(Mapping):
        pass

    class DeleteXssMatchSetResponse(Mapping):
        pass

    class DisassociateWebACLRequest(Mapping):
        pass

    class DisassociateWebACLResponse(Mapping):
        pass

    class GetByteMatchSetRequest(Mapping):
        pass

    class GetByteMatchSetResponse(Mapping):
        pass

    class GetChangeTokenRequest(Mapping):
        pass

    class GetChangeTokenResponse(Mapping):
        pass

    class GetChangeTokenStatusRequest(Mapping):
        pass

    class GetChangeTokenStatusResponse(Mapping):
        pass

    class GetGeoMatchSetRequest(Mapping):
        pass

    class GetGeoMatchSetResponse(Mapping):
        pass

    class GetIPSetRequest(Mapping):
        pass

    class GetIPSetResponse(Mapping):
        pass

    class GetLoggingConfigurationRequest(Mapping):
        pass

    class GetLoggingConfigurationResponse(Mapping):
        pass

    class GetPermissionPolicyRequest(Mapping):
        pass

    class GetPermissionPolicyResponse(Mapping):
        pass

    class GetRateBasedRuleRequest(Mapping):
        pass

    class GetRateBasedRuleResponse(Mapping):
        pass

    class GetRateBasedRuleManagedKeysRequest(Mapping):
        pass

    class GetRateBasedRuleManagedKeysResponse(Mapping):
        pass

    class GetRegexMatchSetRequest(Mapping):
        pass

    class GetRegexMatchSetResponse(Mapping):
        pass

    class GetRegexPatternSetRequest(Mapping):
        pass

    class GetRegexPatternSetResponse(Mapping):
        pass

    class GetRuleRequest(Mapping):
        pass

    class GetRuleResponse(Mapping):
        pass

    class GetRuleGroupRequest(Mapping):
        pass

    class GetRuleGroupResponse(Mapping):
        pass

    class GetSampledRequestsRequest(Mapping):
        pass

    class GetSampledRequestsResponse(Mapping):
        pass

    class TimeWindow(Mapping):
        pass

    class GetSampledRequestsMaxItems(object):
        pass

    class GetSizeConstraintSetRequest(Mapping):
        pass

    class GetSizeConstraintSetResponse(Mapping):
        pass

    class GetSqlInjectionMatchSetRequest(Mapping):
        pass

    class GetSqlInjectionMatchSetResponse(Mapping):
        pass

    class GetWebACLRequest(Mapping):
        pass

    class GetWebACLResponse(Mapping):
        pass

    class GetWebACLForResourceRequest(Mapping):
        pass

    class GetWebACLForResourceResponse(Mapping):
        pass

    class GetXssMatchSetRequest(Mapping):
        pass

    class GetXssMatchSetResponse(Mapping):
        pass

    class ListActivatedRulesInRuleGroupRequest(Mapping):
        pass

    class ListActivatedRulesInRuleGroupResponse(Mapping):
        pass

    class ListByteMatchSetsRequest(Mapping):
        pass

    class ListByteMatchSetsResponse(Mapping):
        pass

    class ListGeoMatchSetsRequest(Mapping):
        pass

    class ListGeoMatchSetsResponse(Mapping):
        pass

    class ListIPSetsRequest(Mapping):
        pass

    class ListIPSetsResponse(Mapping):
        pass

    class ListLoggingConfigurationsRequest(Mapping):
        pass

    class ListLoggingConfigurationsResponse(Mapping):
        pass

    class ListRateBasedRulesRequest(Mapping):
        pass

    class ListRateBasedRulesResponse(Mapping):
        pass

    class ListRegexMatchSetsRequest(Mapping):
        pass

    class ListRegexMatchSetsResponse(Mapping):
        pass

    class ListRegexPatternSetsRequest(Mapping):
        pass

    class ListRegexPatternSetsResponse(Mapping):
        pass

    class ListResourcesForWebACLRequest(Mapping):
        pass

    class ListResourcesForWebACLResponse(Mapping):
        pass

    class ListRuleGroupsRequest(Mapping):
        pass

    class ListRuleGroupsResponse(Mapping):
        pass

    class ListRulesRequest(Mapping):
        pass

    class ListRulesResponse(Mapping):
        pass

    class ListSizeConstraintSetsRequest(Mapping):
        pass

    class ListSizeConstraintSetsResponse(Mapping):
        pass

    class ListSqlInjectionMatchSetsRequest(Mapping):
        pass

    class ListSqlInjectionMatchSetsResponse(Mapping):
        pass

    class ListSubscribedRuleGroupsRequest(Mapping):
        pass

    class ListSubscribedRuleGroupsResponse(Mapping):
        pass

    class ListWebACLsRequest(Mapping):
        pass

    class ListWebACLsResponse(Mapping):
        pass

    class ListXssMatchSetsRequest(Mapping):
        pass

    class ListXssMatchSetsResponse(Mapping):
        pass

    class PutLoggingConfigurationRequest(Mapping):
        pass

    class PutLoggingConfigurationResponse(Mapping):
        pass

    class LoggingConfiguration(Mapping):
        pass

    class PutPermissionPolicyRequest(Mapping):
        pass

    class PutPermissionPolicyResponse(Mapping):
        pass

    class UpdateByteMatchSetRequest(Mapping):
        pass

    class UpdateByteMatchSetResponse(Mapping):
        pass

    class ByteMatchSetUpdate(Mapping):
        pass

    class UpdateGeoMatchSetRequest(Mapping):
        pass

    class UpdateGeoMatchSetResponse(Mapping):
        pass

    class GeoMatchSetUpdate(Mapping):
        pass

    class UpdateIPSetRequest(Mapping):
        pass

    class UpdateIPSetResponse(Mapping):
        pass

    class IPSetUpdate(Mapping):
        pass

    class UpdateRateBasedRuleRequest(Mapping):
        pass

    class UpdateRateBasedRuleResponse(Mapping):
        pass

    class RuleUpdate(Mapping):
        pass

    class UpdateRegexMatchSetRequest(Mapping):
        pass

    class UpdateRegexMatchSetResponse(Mapping):
        pass

    class RegexMatchSetUpdate(Mapping):
        pass

    class UpdateRegexPatternSetRequest(Mapping):
        pass

    class UpdateRegexPatternSetResponse(Mapping):
        pass

    class RegexPatternSetUpdate(Mapping):
        pass

    class UpdateRuleRequest(Mapping):
        pass

    class UpdateRuleResponse(Mapping):
        pass

    class UpdateRuleGroupRequest(Mapping):
        pass

    class UpdateRuleGroupResponse(Mapping):
        pass

    class RuleGroupUpdate(Mapping):
        pass

    class UpdateSizeConstraintSetRequest(Mapping):
        pass

    class UpdateSizeConstraintSetResponse(Mapping):
        pass

    class SizeConstraintSetUpdate(Mapping):
        pass

    class UpdateSqlInjectionMatchSetRequest(Mapping):
        pass

    class UpdateSqlInjectionMatchSetResponse(Mapping):
        pass

    class SqlInjectionMatchSetUpdate(Mapping):
        pass

    class UpdateWebACLRequest(Mapping):
        pass

    class UpdateWebACLResponse(Mapping):
        pass

    class WebACLUpdate(Mapping):
        pass

    class UpdateXssMatchSetRequest(Mapping):
        pass

    class UpdateXssMatchSetResponse(Mapping):
        pass

    class XssMatchSetUpdate(Mapping):
        pass

    def associate_web_acl(self, ResourceArn: str, WebACLId: str) -> AssociateWebACLResponse:
        pass

    def create_byte_match_set(self, ChangeToken: str, Name: str) -> CreateByteMatchSetResponse:
        pass

    def create_geo_match_set(self, ChangeToken: str, Name: str) -> CreateGeoMatchSetResponse:
        pass

    def create_ip_set(self, ChangeToken: str, Name: str) -> CreateIPSetResponse:
        pass

    def create_rate_based_rule(self, ChangeToken: str, RateLimit: RateLimit, RateKey: str, MetricName: str, Name: str) -> CreateRateBasedRuleResponse:
        pass

    def create_regex_match_set(self, ChangeToken: str, Name: str) -> CreateRegexMatchSetResponse:
        pass

    def create_regex_pattern_set(self, ChangeToken: str, Name: str) -> CreateRegexPatternSetResponse:
        pass

    def create_rule(self, ChangeToken: str, MetricName: str, Name: str) -> CreateRuleResponse:
        pass

    def create_rule_group(self, ChangeToken: str, MetricName: str, Name: str) -> CreateRuleGroupResponse:
        pass

    def create_size_constraint_set(self, ChangeToken: str, Name: str) -> CreateSizeConstraintSetResponse:
        pass

    def create_sql_injection_match_set(self, ChangeToken: str, Name: str) -> CreateSqlInjectionMatchSetResponse:
        pass

    def create_web_acl(self, ChangeToken: str, DefaultAction: WafAction, MetricName: str, Name: str) -> CreateWebACLResponse:
        pass

    def create_xss_match_set(self, ChangeToken: str, Name: str) -> CreateXssMatchSetResponse:
        pass

    def delete_byte_match_set(self, ChangeToken: str, ByteMatchSetId: str) -> DeleteByteMatchSetResponse:
        pass

    def delete_geo_match_set(self, ChangeToken: str, GeoMatchSetId: str) -> DeleteGeoMatchSetResponse:
        pass

    def delete_ip_set(self, ChangeToken: str, IPSetId: str) -> DeleteIPSetResponse:
        pass

    def delete_logging_configuration(self, ResourceArn: str) -> DeleteLoggingConfigurationResponse:
        pass

    def delete_permission_policy(self, ResourceArn: str) -> DeletePermissionPolicyResponse:
        pass

    def delete_rate_based_rule(self, ChangeToken: str, RuleId: str) -> DeleteRateBasedRuleResponse:
        pass

    def delete_regex_match_set(self, ChangeToken: str, RegexMatchSetId: str) -> DeleteRegexMatchSetResponse:
        pass

    def delete_regex_pattern_set(self, ChangeToken: str, RegexPatternSetId: str) -> DeleteRegexPatternSetResponse:
        pass

    def delete_rule(self, ChangeToken: str, RuleId: str) -> DeleteRuleResponse:
        pass

    def delete_rule_group(self, ChangeToken: str, RuleGroupId: str) -> DeleteRuleGroupResponse:
        pass

    def delete_size_constraint_set(self, ChangeToken: str, SizeConstraintSetId: str) -> DeleteSizeConstraintSetResponse:
        pass

    def delete_sql_injection_match_set(self, ChangeToken: str, SqlInjectionMatchSetId: str) -> DeleteSqlInjectionMatchSetResponse:
        pass

    def delete_web_acl(self, ChangeToken: str, WebACLId: str) -> DeleteWebACLResponse:
        pass

    def delete_xss_match_set(self, ChangeToken: str, XssMatchSetId: str) -> DeleteXssMatchSetResponse:
        pass

    def disassociate_web_acl(self, ResourceArn: str) -> DisassociateWebACLResponse:
        pass

    def get_byte_match_set(self, ByteMatchSetId: str) -> GetByteMatchSetResponse:
        pass

    def get_change_token(self) -> GetChangeTokenResponse:
        pass

    def get_change_token_status(self, ChangeToken: str) -> GetChangeTokenStatusResponse:
        pass

    def get_geo_match_set(self, GeoMatchSetId: str) -> GetGeoMatchSetResponse:
        pass

    def get_ip_set(self, IPSetId: str) -> GetIPSetResponse:
        pass

    def get_logging_configuration(self, ResourceArn: str) -> GetLoggingConfigurationResponse:
        pass

    def get_permission_policy(self, ResourceArn: str) -> GetPermissionPolicyResponse:
        pass

    def get_rate_based_rule(self, RuleId: str) -> GetRateBasedRuleResponse:
        pass

    def get_rate_based_rule_managed_keys(self, RuleId: str, NextMarker: str=None) -> GetRateBasedRuleManagedKeysResponse:
        pass

    def get_regex_match_set(self, RegexMatchSetId: str) -> GetRegexMatchSetResponse:
        pass

    def get_regex_pattern_set(self, RegexPatternSetId: str) -> GetRegexPatternSetResponse:
        pass

    def get_rule(self, RuleId: str) -> GetRuleResponse:
        pass

    def get_rule_group(self, RuleGroupId: str) -> GetRuleGroupResponse:
        pass

    def get_sampled_requests(self, MaxItems: GetSampledRequestsMaxItems, TimeWindow: TimeWindow, RuleId: str, WebAclId: str) -> GetSampledRequestsResponse:
        pass

    def get_size_constraint_set(self, SizeConstraintSetId: str) -> GetSizeConstraintSetResponse:
        pass

    def get_sql_injection_match_set(self, SqlInjectionMatchSetId: str) -> GetSqlInjectionMatchSetResponse:
        pass

    def get_web_acl(self, WebACLId: str) -> GetWebACLResponse:
        pass

    def get_web_acl_for_resource(self, ResourceArn: str) -> GetWebACLForResourceResponse:
        pass

    def get_xss_match_set(self, XssMatchSetId: str) -> GetXssMatchSetResponse:
        pass

    def list_activated_rules_in_rule_group(self, RuleGroupId: str=None, NextMarker: str=None, Limit: int=None) -> ListActivatedRulesInRuleGroupResponse:
        pass

    def list_byte_match_sets(self, NextMarker: str=None, Limit: int=None) -> ListByteMatchSetsResponse:
        pass

    def list_geo_match_sets(self, NextMarker: str=None, Limit: int=None) -> ListGeoMatchSetsResponse:
        pass

    def list_ip_sets(self, NextMarker: str=None, Limit: int=None) -> ListIPSetsResponse:
        pass

    def list_logging_configurations(self, NextMarker: str=None, Limit: int=None) -> ListLoggingConfigurationsResponse:
        pass

    def list_rate_based_rules(self, NextMarker: str=None, Limit: int=None) -> ListRateBasedRulesResponse:
        pass

    def list_regex_match_sets(self, NextMarker: str=None, Limit: int=None) -> ListRegexMatchSetsResponse:
        pass

    def list_regex_pattern_sets(self, NextMarker: str=None, Limit: int=None) -> ListRegexPatternSetsResponse:
        pass

    def list_resources_for_web_acl(self, WebACLId: str, ResourceType: str=None) -> ListResourcesForWebACLResponse:
        pass

    def list_rule_groups(self, NextMarker: str=None, Limit: int=None) -> ListRuleGroupsResponse:
        pass

    def list_rules(self, NextMarker: str=None, Limit: int=None) -> ListRulesResponse:
        pass

    def list_size_constraint_sets(self, NextMarker: str=None, Limit: int=None) -> ListSizeConstraintSetsResponse:
        pass

    def list_sql_injection_match_sets(self, NextMarker: str=None, Limit: int=None) -> ListSqlInjectionMatchSetsResponse:
        pass

    def list_subscribed_rule_groups(self, NextMarker: str=None, Limit: int=None) -> ListSubscribedRuleGroupsResponse:
        pass

    def list_web_acls(self, NextMarker: str=None, Limit: int=None) -> ListWebACLsResponse:
        pass

    def list_xss_match_sets(self, NextMarker: str=None, Limit: int=None) -> ListXssMatchSetsResponse:
        pass

    def put_logging_configuration(self, LoggingConfiguration: LoggingConfiguration) -> PutLoggingConfigurationResponse:
        pass

    def put_permission_policy(self, Policy: str, ResourceArn: str) -> PutPermissionPolicyResponse:
        pass

    def update_byte_match_set(self, Updates: List[ByteMatchSetUpdate], ChangeToken: str, ByteMatchSetId: str) -> UpdateByteMatchSetResponse:
        pass

    def update_geo_match_set(self, Updates: List[GeoMatchSetUpdate], ChangeToken: str, GeoMatchSetId: str) -> UpdateGeoMatchSetResponse:
        pass

    def update_ip_set(self, Updates: List[IPSetUpdate], ChangeToken: str, IPSetId: str) -> UpdateIPSetResponse:
        pass

    def update_rate_based_rule(self, RateLimit: RateLimit, Updates: List[RuleUpdate], ChangeToken: str, RuleId: str) -> UpdateRateBasedRuleResponse:
        pass

    def update_regex_match_set(self, ChangeToken: str, Updates: List[RegexMatchSetUpdate], RegexMatchSetId: str) -> UpdateRegexMatchSetResponse:
        pass

    def update_regex_pattern_set(self, ChangeToken: str, Updates: List[RegexPatternSetUpdate], RegexPatternSetId: str) -> UpdateRegexPatternSetResponse:
        pass

    def update_rule(self, Updates: List[RuleUpdate], ChangeToken: str, RuleId: str) -> UpdateRuleResponse:
        pass

    def update_rule_group(self, ChangeToken: str, Updates: List[RuleGroupUpdate], RuleGroupId: str) -> UpdateRuleGroupResponse:
        pass

    def update_size_constraint_set(self, Updates: List[SizeConstraintSetUpdate], ChangeToken: str, SizeConstraintSetId: str) -> UpdateSizeConstraintSetResponse:
        pass

    def update_sql_injection_match_set(self, Updates: List[SqlInjectionMatchSetUpdate], ChangeToken: str, SqlInjectionMatchSetId: str) -> UpdateSqlInjectionMatchSetResponse:
        pass

    def update_web_acl(self, ChangeToken: str, WebACLId: str, Updates: List[WebACLUpdate]=None, DefaultAction: WafAction=None) -> UpdateWebACLResponse:
        pass

    def update_xss_match_set(self, Updates: List[XssMatchSetUpdate], ChangeToken: str, XssMatchSetId: str) -> UpdateXssMatchSetResponse:
        pass


class WorkDocs(BaseClient):
    class AbortDocumentVersionUploadRequest(Mapping):
        pass

    class ActivateUserRequest(Mapping):
        pass

    class ActivateUserResponse(Mapping):
        pass

    class AddResourcePermissionsRequest(Mapping):
        pass

    class AddResourcePermissionsResponse(Mapping):
        pass

    class SharePrincipal(Mapping):
        pass

    class NotificationOptions(Mapping):
        pass

    class CreateCommentRequest(Mapping):
        pass

    class CreateCommentResponse(Mapping):
        pass

    class BooleanType(object):
        pass

    class CreateCustomMetadataRequest(Mapping):
        pass

    class CreateCustomMetadataResponse(Mapping):
        pass

    class CustomMetadataMap(object):
        pass

    class CreateFolderRequest(Mapping):
        pass

    class CreateFolderResponse(Mapping):
        pass

    class CreateLabelsRequest(Mapping):
        pass

    class CreateLabelsResponse(Mapping):
        pass

    class SharedLabel(object):
        pass

    class CreateNotificationSubscriptionRequest(Mapping):
        pass

    class CreateNotificationSubscriptionResponse(Mapping):
        pass

    class CreateUserRequest(Mapping):
        pass

    class CreateUserResponse(Mapping):
        pass

    class StorageRuleType(Mapping):
        pass

    class DeactivateUserRequest(Mapping):
        pass

    class DeleteCommentRequest(Mapping):
        pass

    class DeleteCustomMetadataRequest(Mapping):
        pass

    class DeleteCustomMetadataResponse(Mapping):
        pass

    class CustomMetadataKeyType(object):
        pass

    class DeleteDocumentRequest(Mapping):
        pass

    class DeleteFolderRequest(Mapping):
        pass

    class DeleteFolderContentsRequest(Mapping):
        pass

    class DeleteLabelsRequest(Mapping):
        pass

    class DeleteLabelsResponse(Mapping):
        pass

    class DeleteNotificationSubscriptionRequest(Mapping):
        pass

    class DeleteUserRequest(Mapping):
        pass

    class DescribeActivitiesRequest(Mapping):
        pass

    class DescribeActivitiesResponse(Mapping):
        pass

    class TimestampType(object):
        pass

    class DescribeCommentsRequest(Mapping):
        pass

    class DescribeCommentsResponse(Mapping):
        pass

    class DescribeDocumentVersionsRequest(Mapping):
        pass

    class DescribeDocumentVersionsResponse(Mapping):
        pass

    class DescribeFolderContentsRequest(Mapping):
        pass

    class DescribeFolderContentsResponse(Mapping):
        pass

    class DescribeGroupsRequest(Mapping):
        pass

    class DescribeGroupsResponse(Mapping):
        pass

    class DescribeNotificationSubscriptionsRequest(Mapping):
        pass

    class DescribeNotificationSubscriptionsResponse(Mapping):
        pass

    class DescribeResourcePermissionsRequest(Mapping):
        pass

    class DescribeResourcePermissionsResponse(Mapping):
        pass

    class DescribeRootFoldersRequest(Mapping):
        pass

    class DescribeRootFoldersResponse(Mapping):
        pass

    class DescribeUsersRequest(Mapping):
        pass

    class DescribeUsersResponse(Mapping):
        pass

    class GetCurrentUserRequest(Mapping):
        pass

    class GetCurrentUserResponse(Mapping):
        pass

    class GetDocumentRequest(Mapping):
        pass

    class GetDocumentResponse(Mapping):
        pass

    class GetDocumentPathRequest(Mapping):
        pass

    class GetDocumentPathResponse(Mapping):
        pass

    class GetDocumentVersionRequest(Mapping):
        pass

    class GetDocumentVersionResponse(Mapping):
        pass

    class GetFolderRequest(Mapping):
        pass

    class GetFolderResponse(Mapping):
        pass

    class GetFolderPathRequest(Mapping):
        pass

    class GetFolderPathResponse(Mapping):
        pass

    class GetResourcesRequest(Mapping):
        pass

    class GetResourcesResponse(Mapping):
        pass

    class InitiateDocumentVersionUploadRequest(Mapping):
        pass

    class InitiateDocumentVersionUploadResponse(Mapping):
        pass

    class SizeType(object):
        pass

    class RemoveAllResourcePermissionsRequest(Mapping):
        pass

    class RemoveResourcePermissionRequest(Mapping):
        pass

    class UpdateDocumentRequest(Mapping):
        pass

    class UpdateDocumentVersionRequest(Mapping):
        pass

    class UpdateFolderRequest(Mapping):
        pass

    class UpdateUserRequest(Mapping):
        pass

    class UpdateUserResponse(Mapping):
        pass

    def abort_document_version_upload(self, VersionId: str, DocumentId: str, AuthenticationToken: str=None):
        pass

    def activate_user(self, UserId: str, AuthenticationToken: str=None) -> ActivateUserResponse:
        pass

    def add_resource_permissions(self, Principals: List[SharePrincipal], ResourceId: str, AuthenticationToken: str=None, NotificationOptions: NotificationOptions=None) -> AddResourcePermissionsResponse:
        pass

    def create_comment(self, Text: str, VersionId: str, DocumentId: str, AuthenticationToken: str=None, ParentId: str=None, ThreadId: str=None, Visibility: str=None, NotifyCollaborators: BooleanType=None) -> CreateCommentResponse:
        pass

    def create_custom_metadata(self, CustomMetadata: CustomMetadataMap, ResourceId: str, AuthenticationToken: str=None, VersionId: str=None) -> CreateCustomMetadataResponse:
        pass

    def create_folder(self, ParentFolderId: str, AuthenticationToken: str=None, Name: str=None) -> CreateFolderResponse:
        pass

    def create_labels(self, Labels: List[SharedLabel], ResourceId: str, AuthenticationToken: str=None) -> CreateLabelsResponse:
        pass

    def create_notification_subscription(self, SubscriptionType: str, Protocol: str, Endpoint: str, OrganizationId: str) -> CreateNotificationSubscriptionResponse:
        pass

    def create_user(self, Password: str, Surname: str, GivenName: str, Username: str, OrganizationId: str=None, EmailAddress: str=None, TimeZoneId: str=None, StorageRule: StorageRuleType=None, AuthenticationToken: str=None) -> CreateUserResponse:
        pass

    def deactivate_user(self, UserId: str, AuthenticationToken: str=None):
        pass

    def delete_comment(self, CommentId: str, VersionId: str, DocumentId: str, AuthenticationToken: str=None):
        pass

    def delete_custom_metadata(self, ResourceId: str, AuthenticationToken: str=None, VersionId: str=None, Keys: List[CustomMetadataKeyType]=None, DeleteAll: BooleanType=None) -> DeleteCustomMetadataResponse:
        pass

    def delete_document(self, DocumentId: str, AuthenticationToken: str=None):
        pass

    def delete_folder(self, FolderId: str, AuthenticationToken: str=None):
        pass

    def delete_folder_contents(self, FolderId: str, AuthenticationToken: str=None):
        pass

    def delete_labels(self, ResourceId: str, AuthenticationToken: str=None, Labels: List[SharedLabel]=None, DeleteAll: BooleanType=None) -> DeleteLabelsResponse:
        pass

    def delete_notification_subscription(self, OrganizationId: str, SubscriptionId: str):
        pass

    def delete_user(self, UserId: str, AuthenticationToken: str=None):
        pass

    def describe_activities(self, AuthenticationToken: str=None, StartTime: TimestampType=None, EndTime: TimestampType=None, OrganizationId: str=None, ActivityTypes: str=None, ResourceId: str=None, UserId: str=None, IncludeIndirectActivities: BooleanType=None, Limit: int=None, Marker: str=None) -> DescribeActivitiesResponse:
        pass

    def describe_comments(self, VersionId: str, DocumentId: str, AuthenticationToken: str=None, Limit: int=None, Marker: str=None) -> DescribeCommentsResponse:
        pass

    def describe_document_versions(self, DocumentId: str, AuthenticationToken: str=None, Marker: str=None, Limit: int=None, Include: str=None, Fields: str=None) -> DescribeDocumentVersionsResponse:
        pass

    def describe_folder_contents(self, FolderId: str, AuthenticationToken: str=None, Sort: str=None, Order: str=None, Limit: int=None, Marker: str=None, Type: str=None, Include: str=None) -> DescribeFolderContentsResponse:
        pass

    def describe_groups(self, SearchQuery: str, AuthenticationToken: str=None, OrganizationId: str=None, Marker: str=None, Limit: int=None) -> DescribeGroupsResponse:
        pass

    def describe_notification_subscriptions(self, OrganizationId: str, Marker: str=None, Limit: int=None) -> DescribeNotificationSubscriptionsResponse:
        pass

    def describe_resource_permissions(self, ResourceId: str, AuthenticationToken: str=None, PrincipalId: str=None, Limit: int=None, Marker: str=None) -> DescribeResourcePermissionsResponse:
        pass

    def describe_root_folders(self, AuthenticationToken: str, Limit: int=None, Marker: str=None) -> DescribeRootFoldersResponse:
        pass

    def describe_users(self, AuthenticationToken: str=None, OrganizationId: str=None, UserIds: str=None, Query: str=None, Include: str=None, Order: str=None, Sort: str=None, Marker: str=None, Limit: int=None, Fields: str=None) -> DescribeUsersResponse:
        pass

    def get_current_user(self, AuthenticationToken: str) -> GetCurrentUserResponse:
        pass

    def get_document(self, DocumentId: str, AuthenticationToken: str=None, IncludeCustomMetadata: BooleanType=None) -> GetDocumentResponse:
        pass

    def get_document_path(self, DocumentId: str, AuthenticationToken: str=None, Limit: int=None, Fields: str=None, Marker: str=None) -> GetDocumentPathResponse:
        pass

    def get_document_version(self, VersionId: str, DocumentId: str, AuthenticationToken: str=None, Fields: str=None, IncludeCustomMetadata: BooleanType=None) -> GetDocumentVersionResponse:
        pass

    def get_folder(self, FolderId: str, AuthenticationToken: str=None, IncludeCustomMetadata: BooleanType=None) -> GetFolderResponse:
        pass

    def get_folder_path(self, FolderId: str, AuthenticationToken: str=None, Limit: int=None, Fields: str=None, Marker: str=None) -> GetFolderPathResponse:
        pass

    def get_resources(self, AuthenticationToken: str=None, UserId: str=None, CollectionType: str=None, Limit: int=None, Marker: str=None) -> GetResourcesResponse:
        pass

    def initiate_document_version_upload(self, ParentFolderId: str, AuthenticationToken: str=None, Id: str=None, Name: str=None, ContentCreatedTimestamp: TimestampType=None, ContentModifiedTimestamp: TimestampType=None, ContentType: str=None, DocumentSizeInBytes: SizeType=None) -> InitiateDocumentVersionUploadResponse:
        pass

    def remove_all_resource_permissions(self, ResourceId: str, AuthenticationToken: str=None):
        pass

    def remove_resource_permission(self, PrincipalId: str, ResourceId: str, AuthenticationToken: str=None, PrincipalType: str=None):
        pass

    def update_document(self, DocumentId: str, AuthenticationToken: str=None, Name: str=None, ParentFolderId: str=None, ResourceState: str=None):
        pass

    def update_document_version(self, VersionId: str, DocumentId: str, AuthenticationToken: str=None, VersionStatus: str=None):
        pass

    def update_folder(self, FolderId: str, AuthenticationToken: str=None, Name: str=None, ParentFolderId: str=None, ResourceState: str=None):
        pass

    def update_user(self, UserId: str, AuthenticationToken: str=None, GivenName: str=None, Surname: str=None, Type: str=None, StorageRule: StorageRuleType=None, TimeZoneId: str=None, Locale: str=None, GrantPoweruserPrivileges: str=None) -> UpdateUserResponse:
        pass


class WorkLink(BaseClient):
    class AssociateWebsiteCertificateAuthorityRequest(Mapping):
        pass

    class AssociateWebsiteCertificateAuthorityResponse(Mapping):
        pass

    class CreateFleetRequest(Mapping):
        pass

    class CreateFleetResponse(Mapping):
        pass

    class Boolean(object):
        pass

    class DeleteFleetRequest(Mapping):
        pass

    class DeleteFleetResponse(Mapping):
        pass

    class DescribeAuditStreamConfigurationRequest(Mapping):
        pass

    class DescribeAuditStreamConfigurationResponse(Mapping):
        pass

    class DescribeCompanyNetworkConfigurationRequest(Mapping):
        pass

    class DescribeCompanyNetworkConfigurationResponse(Mapping):
        pass

    class DescribeDeviceRequest(Mapping):
        pass

    class DescribeDeviceResponse(Mapping):
        pass

    class DescribeDevicePolicyConfigurationRequest(Mapping):
        pass

    class DescribeDevicePolicyConfigurationResponse(Mapping):
        pass

    class DescribeFleetMetadataRequest(Mapping):
        pass

    class DescribeFleetMetadataResponse(Mapping):
        pass

    class DescribeIdentityProviderConfigurationRequest(Mapping):
        pass

    class DescribeIdentityProviderConfigurationResponse(Mapping):
        pass

    class DescribeWebsiteCertificateAuthorityRequest(Mapping):
        pass

    class DescribeWebsiteCertificateAuthorityResponse(Mapping):
        pass

    class DisassociateWebsiteCertificateAuthorityRequest(Mapping):
        pass

    class DisassociateWebsiteCertificateAuthorityResponse(Mapping):
        pass

    class ListDevicesRequest(Mapping):
        pass

    class ListDevicesResponse(Mapping):
        pass

    class ListFleetsRequest(Mapping):
        pass

    class ListFleetsResponse(Mapping):
        pass

    class ListWebsiteCertificateAuthoritiesRequest(Mapping):
        pass

    class ListWebsiteCertificateAuthoritiesResponse(Mapping):
        pass

    class SignOutUserRequest(Mapping):
        pass

    class SignOutUserResponse(Mapping):
        pass

    class UpdateAuditStreamConfigurationRequest(Mapping):
        pass

    class UpdateAuditStreamConfigurationResponse(Mapping):
        pass

    class UpdateCompanyNetworkConfigurationRequest(Mapping):
        pass

    class UpdateCompanyNetworkConfigurationResponse(Mapping):
        pass

    class SubnetId(object):
        pass

    class SecurityGroupId(object):
        pass

    class UpdateDevicePolicyConfigurationRequest(Mapping):
        pass

    class UpdateDevicePolicyConfigurationResponse(Mapping):
        pass

    class UpdateFleetMetadataRequest(Mapping):
        pass

    class UpdateFleetMetadataResponse(Mapping):
        pass

    class UpdateIdentityProviderConfigurationRequest(Mapping):
        pass

    class UpdateIdentityProviderConfigurationResponse(Mapping):
        pass

    def associate_website_certificate_authority(self, Certificate: str, FleetArn: str, DisplayName: str=None) -> AssociateWebsiteCertificateAuthorityResponse:
        pass

    def create_fleet(self, FleetName: str, DisplayName: str=None, OptimizeForEndUserLocation: Boolean=None) -> CreateFleetResponse:
        pass

    def delete_fleet(self, FleetArn: str) -> DeleteFleetResponse:
        pass

    def describe_audit_stream_configuration(self, FleetArn: str) -> DescribeAuditStreamConfigurationResponse:
        pass

    def describe_company_network_configuration(self, FleetArn: str) -> DescribeCompanyNetworkConfigurationResponse:
        pass

    def describe_device(self, DeviceId: str, FleetArn: str) -> DescribeDeviceResponse:
        pass

    def describe_device_policy_configuration(self, FleetArn: str) -> DescribeDevicePolicyConfigurationResponse:
        pass

    def describe_fleet_metadata(self, FleetArn: str) -> DescribeFleetMetadataResponse:
        pass

    def describe_identity_provider_configuration(self, FleetArn: str) -> DescribeIdentityProviderConfigurationResponse:
        pass

    def describe_website_certificate_authority(self, WebsiteCaId: str, FleetArn: str) -> DescribeWebsiteCertificateAuthorityResponse:
        pass

    def disassociate_website_certificate_authority(self, WebsiteCaId: str, FleetArn: str) -> DisassociateWebsiteCertificateAuthorityResponse:
        pass

    def list_devices(self, FleetArn: str, NextToken: str=None, MaxResults: int=None) -> ListDevicesResponse:
        pass

    def list_fleets(self, NextToken: str=None, MaxResults: int=None) -> ListFleetsResponse:
        pass

    def list_website_certificate_authorities(self, FleetArn: str, MaxResults: int=None, NextToken: str=None) -> ListWebsiteCertificateAuthoritiesResponse:
        pass

    def sign_out_user(self, Username: str, FleetArn: str) -> SignOutUserResponse:
        pass

    def update_audit_stream_configuration(self, FleetArn: str, AuditStreamArn: str=None) -> UpdateAuditStreamConfigurationResponse:
        pass

    def update_company_network_configuration(self, SecurityGroupIds: List[SecurityGroupId], SubnetIds: List[SubnetId], VpcId: str, FleetArn: str) -> UpdateCompanyNetworkConfigurationResponse:
        pass

    def update_device_policy_configuration(self, FleetArn: str, DeviceCaCertificate: str=None) -> UpdateDevicePolicyConfigurationResponse:
        pass

    def update_fleet_metadata(self, FleetArn: str, DisplayName: str=None, OptimizeForEndUserLocation: Boolean=None) -> UpdateFleetMetadataResponse:
        pass

    def update_identity_provider_configuration(self, IdentityProviderType: str, FleetArn: str, IdentityProviderSamlMetadata: str=None) -> UpdateIdentityProviderConfigurationResponse:
        pass


class WorkMail(BaseClient):
    class AssociateDelegateToResourceRequest(Mapping):
        pass

    class AssociateDelegateToResourceResponse(Mapping):
        pass

    class AssociateMemberToGroupRequest(Mapping):
        pass

    class AssociateMemberToGroupResponse(Mapping):
        pass

    class CreateAliasRequest(Mapping):
        pass

    class CreateAliasResponse(Mapping):
        pass

    class CreateGroupRequest(Mapping):
        pass

    class CreateGroupResponse(Mapping):
        pass

    class CreateResourceRequest(Mapping):
        pass

    class CreateResourceResponse(Mapping):
        pass

    class CreateUserRequest(Mapping):
        pass

    class CreateUserResponse(Mapping):
        pass

    class DeleteAliasRequest(Mapping):
        pass

    class DeleteAliasResponse(Mapping):
        pass

    class DeleteGroupRequest(Mapping):
        pass

    class DeleteGroupResponse(Mapping):
        pass

    class DeleteMailboxPermissionsRequest(Mapping):
        pass

    class DeleteMailboxPermissionsResponse(Mapping):
        pass

    class DeleteResourceRequest(Mapping):
        pass

    class DeleteResourceResponse(Mapping):
        pass

    class DeleteUserRequest(Mapping):
        pass

    class DeleteUserResponse(Mapping):
        pass

    class DeregisterFromWorkMailRequest(Mapping):
        pass

    class DeregisterFromWorkMailResponse(Mapping):
        pass

    class DescribeGroupRequest(Mapping):
        pass

    class DescribeGroupResponse(Mapping):
        pass

    class DescribeOrganizationRequest(Mapping):
        pass

    class DescribeOrganizationResponse(Mapping):
        pass

    class DescribeResourceRequest(Mapping):
        pass

    class DescribeResourceResponse(Mapping):
        pass

    class DescribeUserRequest(Mapping):
        pass

    class DescribeUserResponse(Mapping):
        pass

    class DisassociateDelegateFromResourceRequest(Mapping):
        pass

    class DisassociateDelegateFromResourceResponse(Mapping):
        pass

    class DisassociateMemberFromGroupRequest(Mapping):
        pass

    class DisassociateMemberFromGroupResponse(Mapping):
        pass

    class ListAliasesRequest(Mapping):
        pass

    class ListAliasesResponse(Mapping):
        pass

    class ListGroupMembersRequest(Mapping):
        pass

    class ListGroupMembersResponse(Mapping):
        pass

    class ListGroupsRequest(Mapping):
        pass

    class ListGroupsResponse(Mapping):
        pass

    class ListMailboxPermissionsRequest(Mapping):
        pass

    class ListMailboxPermissionsResponse(Mapping):
        pass

    class ListOrganizationsRequest(Mapping):
        pass

    class ListOrganizationsResponse(Mapping):
        pass

    class ListResourceDelegatesRequest(Mapping):
        pass

    class ListResourceDelegatesResponse(Mapping):
        pass

    class ListResourcesRequest(Mapping):
        pass

    class ListResourcesResponse(Mapping):
        pass

    class ListUsersRequest(Mapping):
        pass

    class ListUsersResponse(Mapping):
        pass

    class PutMailboxPermissionsRequest(Mapping):
        pass

    class PutMailboxPermissionsResponse(Mapping):
        pass

    class PermissionType(object):
        pass

    class RegisterToWorkMailRequest(Mapping):
        pass

    class RegisterToWorkMailResponse(Mapping):
        pass

    class ResetPasswordRequest(Mapping):
        pass

    class ResetPasswordResponse(Mapping):
        pass

    class UpdatePrimaryEmailAddressRequest(Mapping):
        pass

    class UpdatePrimaryEmailAddressResponse(Mapping):
        pass

    class UpdateResourceRequest(Mapping):
        pass

    class UpdateResourceResponse(Mapping):
        pass

    class BookingOptions(Mapping):
        pass

    def associate_delegate_to_resource(self, EntityId: str, ResourceId: str, OrganizationId: str) -> AssociateDelegateToResourceResponse:
        pass

    def associate_member_to_group(self, MemberId: str, GroupId: str, OrganizationId: str) -> AssociateMemberToGroupResponse:
        pass

    def create_alias(self, Alias: str, EntityId: str, OrganizationId: str) -> CreateAliasResponse:
        pass

    def create_group(self, Name: str, OrganizationId: str) -> CreateGroupResponse:
        pass

    def create_resource(self, Type: str, Name: str, OrganizationId: str) -> CreateResourceResponse:
        pass

    def create_user(self, Password: str, DisplayName: str, Name: str, OrganizationId: str) -> CreateUserResponse:
        pass

    def delete_alias(self, Alias: str, EntityId: str, OrganizationId: str) -> DeleteAliasResponse:
        pass

    def delete_group(self, GroupId: str, OrganizationId: str) -> DeleteGroupResponse:
        pass

    def delete_mailbox_permissions(self, GranteeId: str, EntityId: str, OrganizationId: str) -> DeleteMailboxPermissionsResponse:
        pass

    def delete_resource(self, ResourceId: str, OrganizationId: str) -> DeleteResourceResponse:
        pass

    def delete_user(self, UserId: str, OrganizationId: str) -> DeleteUserResponse:
        pass

    def deregister_from_work_mail(self, EntityId: str, OrganizationId: str) -> DeregisterFromWorkMailResponse:
        pass

    def describe_group(self, GroupId: str, OrganizationId: str) -> DescribeGroupResponse:
        pass

    def describe_organization(self, OrganizationId: str) -> DescribeOrganizationResponse:
        pass

    def describe_resource(self, ResourceId: str, OrganizationId: str) -> DescribeResourceResponse:
        pass

    def describe_user(self, UserId: str, OrganizationId: str) -> DescribeUserResponse:
        pass

    def disassociate_delegate_from_resource(self, EntityId: str, ResourceId: str, OrganizationId: str) -> DisassociateDelegateFromResourceResponse:
        pass

    def disassociate_member_from_group(self, MemberId: str, GroupId: str, OrganizationId: str) -> DisassociateMemberFromGroupResponse:
        pass

    def list_aliases(self, EntityId: str, OrganizationId: str, NextToken: str=None, MaxResults: int=None) -> ListAliasesResponse:
        pass

    def list_group_members(self, GroupId: str, OrganizationId: str, NextToken: str=None, MaxResults: int=None) -> ListGroupMembersResponse:
        pass

    def list_groups(self, OrganizationId: str, NextToken: str=None, MaxResults: int=None) -> ListGroupsResponse:
        pass

    def list_mailbox_permissions(self, EntityId: str, OrganizationId: str, NextToken: str=None, MaxResults: int=None) -> ListMailboxPermissionsResponse:
        pass

    def list_organizations(self, NextToken: str=None, MaxResults: int=None) -> ListOrganizationsResponse:
        pass

    def list_resource_delegates(self, ResourceId: str, OrganizationId: str, NextToken: str=None, MaxResults: int=None) -> ListResourceDelegatesResponse:
        pass

    def list_resources(self, OrganizationId: str, NextToken: str=None, MaxResults: int=None) -> ListResourcesResponse:
        pass

    def list_users(self, OrganizationId: str, NextToken: str=None, MaxResults: int=None) -> ListUsersResponse:
        pass

    def put_mailbox_permissions(self, PermissionValues: List[PermissionType], GranteeId: str, EntityId: str, OrganizationId: str) -> PutMailboxPermissionsResponse:
        pass

    def register_to_work_mail(self, Email: str, EntityId: str, OrganizationId: str) -> RegisterToWorkMailResponse:
        pass

    def reset_password(self, Password: str, UserId: str, OrganizationId: str) -> ResetPasswordResponse:
        pass

    def update_primary_email_address(self, Email: str, EntityId: str, OrganizationId: str) -> UpdatePrimaryEmailAddressResponse:
        pass

    def update_resource(self, ResourceId: str, OrganizationId: str, Name: str=None, BookingOptions: BookingOptions=None) -> UpdateResourceResponse:
        pass


class WorkSpaces(BaseClient):
    class AssociateIpGroupsRequest(Mapping):
        pass

    class AssociateIpGroupsResult(Mapping):
        pass

    class IpGroupId(object):
        pass

    class AuthorizeIpRulesRequest(Mapping):
        pass

    class AuthorizeIpRulesResult(Mapping):
        pass

    class IpRuleItem(Mapping):
        pass

    class CreateIpGroupRequest(Mapping):
        pass

    class CreateIpGroupResult(Mapping):
        pass

    class CreateTagsRequest(Mapping):
        pass

    class CreateTagsResult(Mapping):
        pass

    class Tag(Mapping):
        pass

    class CreateWorkspacesRequest(Mapping):
        pass

    class CreateWorkspacesResult(Mapping):
        pass

    class WorkspaceRequest(Mapping):
        pass

    class DeleteIpGroupRequest(Mapping):
        pass

    class DeleteIpGroupResult(Mapping):
        pass

    class DeleteTagsRequest(Mapping):
        pass

    class DeleteTagsResult(Mapping):
        pass

    class NonEmptyString(object):
        pass

    class DeleteWorkspaceImageRequest(Mapping):
        pass

    class DeleteWorkspaceImageResult(Mapping):
        pass

    class DescribeAccountRequest(Mapping):
        pass

    class DescribeAccountResult(Mapping):
        pass

    class DescribeAccountModificationsRequest(Mapping):
        pass

    class DescribeAccountModificationsResult(Mapping):
        pass

    class DescribeClientPropertiesRequest(Mapping):
        pass

    class DescribeClientPropertiesResult(Mapping):
        pass

    class DescribeIpGroupsRequest(Mapping):
        pass

    class DescribeIpGroupsResult(Mapping):
        pass

    class DescribeTagsRequest(Mapping):
        pass

    class DescribeTagsResult(Mapping):
        pass

    class DescribeWorkspaceBundlesRequest(Mapping):
        pass

    class DescribeWorkspaceBundlesResult(Mapping):
        pass

    class BundleId(object):
        pass

    class DescribeWorkspaceDirectoriesRequest(Mapping):
        pass

    class DescribeWorkspaceDirectoriesResult(Mapping):
        pass

    class DirectoryId(object):
        pass

    class DescribeWorkspaceImagesRequest(Mapping):
        pass

    class DescribeWorkspaceImagesResult(Mapping):
        pass

    class WorkspaceImageId(object):
        pass

    class DescribeWorkspacesRequest(Mapping):
        pass

    class DescribeWorkspacesResult(Mapping):
        pass

    class WorkspaceId(object):
        pass

    class DescribeWorkspacesConnectionStatusRequest(Mapping):
        pass

    class DescribeWorkspacesConnectionStatusResult(Mapping):
        pass

    class DisassociateIpGroupsRequest(Mapping):
        pass

    class DisassociateIpGroupsResult(Mapping):
        pass

    class ImportWorkspaceImageRequest(Mapping):
        pass

    class ImportWorkspaceImageResult(Mapping):
        pass

    class ListAvailableManagementCidrRangesRequest(Mapping):
        pass

    class ListAvailableManagementCidrRangesResult(Mapping):
        pass

    class ModifyAccountRequest(Mapping):
        pass

    class ModifyAccountResult(Mapping):
        pass

    class ModifyClientPropertiesRequest(Mapping):
        pass

    class ModifyClientPropertiesResult(Mapping):
        pass

    class ClientProperties(Mapping):
        pass

    class ModifyWorkspacePropertiesRequest(Mapping):
        pass

    class ModifyWorkspacePropertiesResult(Mapping):
        pass

    class WorkspaceProperties(Mapping):
        pass

    class ModifyWorkspaceStateRequest(Mapping):
        pass

    class ModifyWorkspaceStateResult(Mapping):
        pass

    class RebootWorkspacesRequest(Mapping):
        pass

    class RebootWorkspacesResult(Mapping):
        pass

    class RebootRequest(Mapping):
        pass

    class RebuildWorkspacesRequest(Mapping):
        pass

    class RebuildWorkspacesResult(Mapping):
        pass

    class RebuildRequest(Mapping):
        pass

    class RevokeIpRulesRequest(Mapping):
        pass

    class RevokeIpRulesResult(Mapping):
        pass

    class IpRule(object):
        pass

    class StartWorkspacesRequest(Mapping):
        pass

    class StartWorkspacesResult(Mapping):
        pass

    class StartRequest(Mapping):
        pass

    class StopWorkspacesRequest(Mapping):
        pass

    class StopWorkspacesResult(Mapping):
        pass

    class StopRequest(Mapping):
        pass

    class TerminateWorkspacesRequest(Mapping):
        pass

    class TerminateWorkspacesResult(Mapping):
        pass

    class TerminateRequest(Mapping):
        pass

    class UpdateRulesOfIpGroupRequest(Mapping):
        pass

    class UpdateRulesOfIpGroupResult(Mapping):
        pass

    def associate_ip_groups(self, GroupIds: List[IpGroupId], DirectoryId: str) -> AssociateIpGroupsResult:
        pass

    def authorize_ip_rules(self, UserRules: List[IpRuleItem], GroupId: str) -> AuthorizeIpRulesResult:
        pass

    def create_ip_group(self, GroupName: str, GroupDesc: str=None, UserRules: List[IpRuleItem]=None) -> CreateIpGroupResult:
        pass

    def create_tags(self, Tags: List[Tag], ResourceId: str) -> CreateTagsResult:
        pass

    def create_workspaces(self, Workspaces: List[WorkspaceRequest]) -> CreateWorkspacesResult:
        pass

    def delete_ip_group(self, GroupId: str) -> DeleteIpGroupResult:
        pass

    def delete_tags(self, TagKeys: List[NonEmptyString], ResourceId: str) -> DeleteTagsResult:
        pass

    def delete_workspace_image(self, ImageId: str) -> DeleteWorkspaceImageResult:
        pass

    def describe_account(self) -> DescribeAccountResult:
        pass

    def describe_account_modifications(self, NextToken: str=None) -> DescribeAccountModificationsResult:
        pass

    def describe_client_properties(self, ResourceIds: List[NonEmptyString]) -> DescribeClientPropertiesResult:
        pass

    def describe_ip_groups(self, GroupIds: List[IpGroupId]=None, NextToken: str=None, MaxResults: int=None) -> DescribeIpGroupsResult:
        pass

    def describe_tags(self, ResourceId: str) -> DescribeTagsResult:
        pass

    def describe_workspace_bundles(self, BundleIds: List[BundleId]=None, Owner: str=None, NextToken: str=None) -> DescribeWorkspaceBundlesResult:
        pass

    def describe_workspace_directories(self, DirectoryIds: List[DirectoryId]=None, NextToken: str=None) -> DescribeWorkspaceDirectoriesResult:
        pass

    def describe_workspace_images(self, ImageIds: List[WorkspaceImageId]=None, NextToken: str=None, MaxResults: int=None) -> DescribeWorkspaceImagesResult:
        pass

    def describe_workspaces(self, WorkspaceIds: List[WorkspaceId]=None, DirectoryId: str=None, UserName: str=None, BundleId: str=None, Limit: int=None, NextToken: str=None) -> DescribeWorkspacesResult:
        pass

    def describe_workspaces_connection_status(self, WorkspaceIds: List[WorkspaceId]=None, NextToken: str=None) -> DescribeWorkspacesConnectionStatusResult:
        pass

    def disassociate_ip_groups(self, GroupIds: List[IpGroupId], DirectoryId: str) -> DisassociateIpGroupsResult:
        pass

    def import_workspace_image(self, ImageDescription: str, ImageName: str, IngestionProcess: str, Ec2ImageId: str) -> ImportWorkspaceImageResult:
        pass

    def list_available_management_cidr_ranges(self, ManagementCidrRangeConstraint: str, MaxResults: int=None, NextToken: str=None) -> ListAvailableManagementCidrRangesResult:
        pass

    def modify_account(self, DedicatedTenancySupport: str=None, DedicatedTenancyManagementCidrRange: str=None) -> ModifyAccountResult:
        pass

    def modify_client_properties(self, ClientProperties: ClientProperties, ResourceId: str) -> ModifyClientPropertiesResult:
        pass

    def modify_workspace_properties(self, WorkspaceProperties: WorkspaceProperties, WorkspaceId: str) -> ModifyWorkspacePropertiesResult:
        pass

    def modify_workspace_state(self, WorkspaceState: str, WorkspaceId: str) -> ModifyWorkspaceStateResult:
        pass

    def reboot_workspaces(self, RebootWorkspaceRequests: List[RebootRequest]) -> RebootWorkspacesResult:
        pass

    def rebuild_workspaces(self, RebuildWorkspaceRequests: List[RebuildRequest]) -> RebuildWorkspacesResult:
        pass

    def revoke_ip_rules(self, UserRules: List[IpRule], GroupId: str) -> RevokeIpRulesResult:
        pass

    def start_workspaces(self, StartWorkspaceRequests: List[StartRequest]) -> StartWorkspacesResult:
        pass

    def stop_workspaces(self, StopWorkspaceRequests: List[StopRequest]) -> StopWorkspacesResult:
        pass

    def terminate_workspaces(self, TerminateWorkspaceRequests: List[TerminateRequest]) -> TerminateWorkspacesResult:
        pass

    def update_rules_of_ip_group(self, UserRules: List[IpRuleItem], GroupId: str) -> UpdateRulesOfIpGroupResult:
        pass


class XRay(BaseClient):
    class BatchGetTracesRequest(Mapping):
        pass

    class BatchGetTracesResult(Mapping):
        pass

    class TraceId(object):
        pass

    class CreateGroupRequest(Mapping):
        pass

    class CreateGroupResult(Mapping):
        pass

    class CreateSamplingRuleRequest(Mapping):
        pass

    class CreateSamplingRuleResult(Mapping):
        pass

    class SamplingRule(Mapping):
        pass

    class DeleteGroupRequest(Mapping):
        pass

    class DeleteGroupResult(Mapping):
        pass

    class DeleteSamplingRuleRequest(Mapping):
        pass

    class DeleteSamplingRuleResult(Mapping):
        pass

    class GetEncryptionConfigRequest(Mapping):
        pass

    class GetEncryptionConfigResult(Mapping):
        pass

    class GetGroupRequest(Mapping):
        pass

    class GetGroupResult(Mapping):
        pass

    class GetGroupsRequest(Mapping):
        pass

    class GetGroupsResult(Mapping):
        pass

    class GetSamplingRulesRequest(Mapping):
        pass

    class GetSamplingRulesResult(Mapping):
        pass

    class GetSamplingStatisticSummariesRequest(Mapping):
        pass

    class GetSamplingStatisticSummariesResult(Mapping):
        pass

    class GetSamplingTargetsRequest(Mapping):
        pass

    class GetSamplingTargetsResult(Mapping):
        pass

    class SamplingStatisticsDocument(Mapping):
        pass

    class GetServiceGraphRequest(Mapping):
        pass

    class GetServiceGraphResult(Mapping):
        pass

    class Timestamp(object):
        pass

    class GetTraceGraphRequest(Mapping):
        pass

    class GetTraceGraphResult(Mapping):
        pass

    class GetTraceSummariesRequest(Mapping):
        pass

    class GetTraceSummariesResult(Mapping):
        pass

    class NullableBoolean(object):
        pass

    class PutEncryptionConfigRequest(Mapping):
        pass

    class PutEncryptionConfigResult(Mapping):
        pass

    class PutTelemetryRecordsRequest(Mapping):
        pass

    class PutTelemetryRecordsResult(Mapping):
        pass

    class TelemetryRecord(Mapping):
        pass

    class PutTraceSegmentsRequest(Mapping):
        pass

    class PutTraceSegmentsResult(Mapping):
        pass

    class TraceSegmentDocument(object):
        pass

    class UpdateGroupRequest(Mapping):
        pass

    class UpdateGroupResult(Mapping):
        pass

    class UpdateSamplingRuleRequest(Mapping):
        pass

    class UpdateSamplingRuleResult(Mapping):
        pass

    class SamplingRuleUpdate(Mapping):
        pass

    def batch_get_traces(self, TraceIds: List[TraceId], NextToken: str=None) -> BatchGetTracesResult:
        pass

    def create_group(self, GroupName: str, FilterExpression: str=None) -> CreateGroupResult:
        pass

    def create_sampling_rule(self, SamplingRule: SamplingRule) -> CreateSamplingRuleResult:
        pass

    def delete_group(self, GroupName: str=None, GroupARN: str=None) -> DeleteGroupResult:
        pass

    def delete_sampling_rule(self, RuleName: str=None, RuleARN: str=None) -> DeleteSamplingRuleResult:
        pass

    def get_encryption_config(self) -> GetEncryptionConfigResult:
        pass

    def get_group(self, GroupName: str=None, GroupARN: str=None) -> GetGroupResult:
        pass

    def get_groups(self, NextToken: str=None) -> GetGroupsResult:
        pass

    def get_sampling_rules(self, NextToken: str=None) -> GetSamplingRulesResult:
        pass

    def get_sampling_statistic_summaries(self, NextToken: str=None) -> GetSamplingStatisticSummariesResult:
        pass

    def get_sampling_targets(self, SamplingStatisticsDocuments: List[SamplingStatisticsDocument]) -> GetSamplingTargetsResult:
        pass

    def get_service_graph(self, EndTime: Timestamp, StartTime: Timestamp, GroupName: str=None, GroupARN: str=None, NextToken: str=None) -> GetServiceGraphResult:
        pass

    def get_trace_graph(self, TraceIds: List[TraceId], NextToken: str=None) -> GetTraceGraphResult:
        pass

    def get_trace_summaries(self, EndTime: Timestamp, StartTime: Timestamp, Sampling: NullableBoolean=None, FilterExpression: str=None, NextToken: str=None) -> GetTraceSummariesResult:
        pass

    def put_encryption_config(self, Type: str, KeyId: str=None) -> PutEncryptionConfigResult:
        pass

    def put_telemetry_records(self, TelemetryRecords: List[TelemetryRecord], EC2InstanceId: str=None, Hostname: str=None, ResourceARN: str=None) -> PutTelemetryRecordsResult:
        pass

    def put_trace_segments(self, TraceSegmentDocuments: List[TraceSegmentDocument]) -> PutTraceSegmentsResult:
        pass

    def update_group(self, GroupName: str=None, GroupARN: str=None, FilterExpression: str=None) -> UpdateGroupResult:
        pass

    def update_sampling_rule(self, SamplingRuleUpdate: SamplingRuleUpdate) -> UpdateSamplingRuleResult:
        pass


