@aws-sdk/client-organizations 3.50.0 → 3.53.0

package/dist-types/ts3.4/models/models_0.d.ts

@@ -0,0 +1,1655 @@
+import { ExceptionOptionType as __ExceptionOptionType } from "@aws-sdk/smithy-client";
+import { OrganizationsServiceException as __BaseException } from "./OrganizationsServiceException";
+export interface AcceptHandshakeRequest {
+    
+    HandshakeId: string | undefined;
+}
+export declare namespace AcceptHandshakeRequest {
+    
+    const filterSensitiveLog: (obj: AcceptHandshakeRequest) => any;
+}
+export declare enum ActionType {
+    ADD_ORGANIZATIONS_SERVICE_LINKED_ROLE = "ADD_ORGANIZATIONS_SERVICE_LINKED_ROLE",
+    APPROVE_ALL_FEATURES = "APPROVE_ALL_FEATURES",
+    ENABLE_ALL_FEATURES = "ENABLE_ALL_FEATURES",
+    INVITE_ACCOUNT_TO_ORGANIZATION = "INVITE"
+}
+export declare enum HandshakePartyType {
+    ACCOUNT = "ACCOUNT",
+    EMAIL = "EMAIL",
+    ORGANIZATION = "ORGANIZATION"
+}
+
+export interface HandshakeParty {
+    
+    Id: string | undefined;
+    
+    Type: HandshakePartyType | string | undefined;
+}
+export declare namespace HandshakeParty {
+    
+    const filterSensitiveLog: (obj: HandshakeParty) => any;
+}
+export declare enum HandshakeResourceType {
+    ACCOUNT = "ACCOUNT",
+    EMAIL = "EMAIL",
+    MASTER_EMAIL = "MASTER_EMAIL",
+    MASTER_NAME = "MASTER_NAME",
+    NOTES = "NOTES",
+    ORGANIZATION = "ORGANIZATION",
+    ORGANIZATION_FEATURE_SET = "ORGANIZATION_FEATURE_SET",
+    PARENT_HANDSHAKE = "PARENT_HANDSHAKE"
+}
+export declare enum HandshakeState {
+    ACCEPTED = "ACCEPTED",
+    CANCELED = "CANCELED",
+    DECLINED = "DECLINED",
+    EXPIRED = "EXPIRED",
+    OPEN = "OPEN",
+    REQUESTED = "REQUESTED"
+}
+
+export declare class AccessDeniedException extends __BaseException {
+    readonly name: "AccessDeniedException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<AccessDeniedException, __BaseException>);
+}
+export declare enum AccessDeniedForDependencyExceptionReason {
+    ACCESS_DENIED_DURING_CREATE_SERVICE_LINKED_ROLE = "ACCESS_DENIED_DURING_CREATE_SERVICE_LINKED_ROLE"
+}
+
+export declare class AccessDeniedForDependencyException extends __BaseException {
+    readonly name: "AccessDeniedForDependencyException";
+    readonly $fault: "client";
+    Message?: string;
+    Reason?: AccessDeniedForDependencyExceptionReason | string;
+    
+    constructor(opts: __ExceptionOptionType<AccessDeniedForDependencyException, __BaseException>);
+}
+
+export declare class AWSOrganizationsNotInUseException extends __BaseException {
+    readonly name: "AWSOrganizationsNotInUseException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<AWSOrganizationsNotInUseException, __BaseException>);
+}
+
+export declare class ConcurrentModificationException extends __BaseException {
+    readonly name: "ConcurrentModificationException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<ConcurrentModificationException, __BaseException>);
+}
+
+export declare class HandshakeAlreadyInStateException extends __BaseException {
+    readonly name: "HandshakeAlreadyInStateException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<HandshakeAlreadyInStateException, __BaseException>);
+}
+export declare enum HandshakeConstraintViolationExceptionReason {
+    ACCOUNT_NUMBER_LIMIT_EXCEEDED = "ACCOUNT_NUMBER_LIMIT_EXCEEDED",
+    ALREADY_IN_AN_ORGANIZATION = "ALREADY_IN_AN_ORGANIZATION",
+    HANDSHAKE_RATE_LIMIT_EXCEEDED = "HANDSHAKE_RATE_LIMIT_EXCEEDED",
+    INVITE_DISABLED_DURING_ENABLE_ALL_FEATURES = "INVITE_DISABLED_DURING_ENABLE_ALL_FEATURES",
+    ORGANIZATION_ALREADY_HAS_ALL_FEATURES = "ORGANIZATION_ALREADY_HAS_ALL_FEATURES",
+    ORGANIZATION_FROM_DIFFERENT_SELLER_OF_RECORD = "ORGANIZATION_FROM_DIFFERENT_SELLER_OF_RECORD",
+    ORGANIZATION_IS_ALREADY_PENDING_ALL_FEATURES_MIGRATION = "ORGANIZATION_IS_ALREADY_PENDING_ALL_FEATURES_MIGRATION",
+    ORGANIZATION_MEMBERSHIP_CHANGE_RATE_LIMIT_EXCEEDED = "ORGANIZATION_MEMBERSHIP_CHANGE_RATE_LIMIT_EXCEEDED",
+    PAYMENT_INSTRUMENT_REQUIRED = "PAYMENT_INSTRUMENT_REQUIRED"
+}
+
+export declare class HandshakeConstraintViolationException extends __BaseException {
+    readonly name: "HandshakeConstraintViolationException";
+    readonly $fault: "client";
+    Message?: string;
+    Reason?: HandshakeConstraintViolationExceptionReason | string;
+    
+    constructor(opts: __ExceptionOptionType<HandshakeConstraintViolationException, __BaseException>);
+}
+
+export declare class HandshakeNotFoundException extends __BaseException {
+    readonly name: "HandshakeNotFoundException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<HandshakeNotFoundException, __BaseException>);
+}
+
+export declare class InvalidHandshakeTransitionException extends __BaseException {
+    readonly name: "InvalidHandshakeTransitionException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<InvalidHandshakeTransitionException, __BaseException>);
+}
+export declare enum InvalidInputExceptionReason {
+    DUPLICATE_TAG_KEY = "DUPLICATE_TAG_KEY",
+    IMMUTABLE_POLICY = "IMMUTABLE_POLICY",
+    INPUT_REQUIRED = "INPUT_REQUIRED",
+    INVALID_EMAIL_ADDRESS_TARGET = "INVALID_EMAIL_ADDRESS_TARGET",
+    INVALID_ENUM = "INVALID_ENUM",
+    INVALID_ENUM_POLICY_TYPE = "INVALID_ENUM_POLICY_TYPE",
+    INVALID_FULL_NAME_TARGET = "INVALID_FULL_NAME_TARGET",
+    INVALID_LIST_MEMBER = "INVALID_LIST_MEMBER",
+    INVALID_PAGINATION_TOKEN = "INVALID_NEXT_TOKEN",
+    INVALID_PARTY_TYPE_TARGET = "INVALID_PARTY_TYPE_TARGET",
+    INVALID_PATTERN = "INVALID_PATTERN",
+    INVALID_PATTERN_TARGET_ID = "INVALID_PATTERN_TARGET_ID",
+    INVALID_ROLE_NAME = "INVALID_ROLE_NAME",
+    INVALID_SYNTAX_ORGANIZATION = "INVALID_SYNTAX_ORGANIZATION_ARN",
+    INVALID_SYNTAX_POLICY = "INVALID_SYNTAX_POLICY_ID",
+    INVALID_SYSTEM_TAGS_PARAMETER = "INVALID_SYSTEM_TAGS_PARAMETER",
+    MAX_FILTER_LIMIT_EXCEEDED = "MAX_LIMIT_EXCEEDED_FILTER",
+    MAX_LENGTH_EXCEEDED = "MAX_LENGTH_EXCEEDED",
+    MAX_VALUE_EXCEEDED = "MAX_VALUE_EXCEEDED",
+    MIN_LENGTH_EXCEEDED = "MIN_LENGTH_EXCEEDED",
+    MIN_VALUE_EXCEEDED = "MIN_VALUE_EXCEEDED",
+    MOVING_ACCOUNT_BETWEEN_DIFFERENT_ROOTS = "MOVING_ACCOUNT_BETWEEN_DIFFERENT_ROOTS",
+    TARGET_NOT_SUPPORTED = "TARGET_NOT_SUPPORTED",
+    UNRECOGNIZED_SERVICE_PRINCIPAL = "UNRECOGNIZED_SERVICE_PRINCIPAL"
+}
+
+export declare class InvalidInputException extends __BaseException {
+    readonly name: "InvalidInputException";
+    readonly $fault: "client";
+    Message?: string;
+    Reason?: InvalidInputExceptionReason | string;
+    
+    constructor(opts: __ExceptionOptionType<InvalidInputException, __BaseException>);
+}
+
+export declare class ServiceException extends __BaseException {
+    readonly name: "ServiceException";
+    readonly $fault: "server";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<ServiceException, __BaseException>);
+}
+
+export declare class TooManyRequestsException extends __BaseException {
+    readonly name: "TooManyRequestsException";
+    readonly $fault: "client";
+    Type?: string;
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<TooManyRequestsException, __BaseException>);
+}
+export declare enum AccountJoinedMethod {
+    CREATED = "CREATED",
+    INVITED = "INVITED"
+}
+export declare enum AccountStatus {
+    ACTIVE = "ACTIVE",
+    SUSPENDED = "SUSPENDED"
+}
+
+export interface Account {
+    
+    Id?: string;
+    
+    Arn?: string;
+    
+    Email?: string;
+    
+    Name?: string;
+    
+    Status?: AccountStatus | string;
+    
+    JoinedMethod?: AccountJoinedMethod | string;
+    
+    JoinedTimestamp?: Date;
+}
+export declare namespace Account {
+    
+    const filterSensitiveLog: (obj: Account) => any;
+}
+
+export declare class AccountAlreadyRegisteredException extends __BaseException {
+    readonly name: "AccountAlreadyRegisteredException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<AccountAlreadyRegisteredException, __BaseException>);
+}
+
+export declare class AccountNotFoundException extends __BaseException {
+    readonly name: "AccountNotFoundException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<AccountNotFoundException, __BaseException>);
+}
+
+export declare class AccountNotRegisteredException extends __BaseException {
+    readonly name: "AccountNotRegisteredException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<AccountNotRegisteredException, __BaseException>);
+}
+
+export declare class AccountOwnerNotVerifiedException extends __BaseException {
+    readonly name: "AccountOwnerNotVerifiedException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<AccountOwnerNotVerifiedException, __BaseException>);
+}
+
+export declare class AlreadyInOrganizationException extends __BaseException {
+    readonly name: "AlreadyInOrganizationException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<AlreadyInOrganizationException, __BaseException>);
+}
+export interface AttachPolicyRequest {
+    
+    PolicyId: string | undefined;
+    
+    TargetId: string | undefined;
+}
+export declare namespace AttachPolicyRequest {
+    
+    const filterSensitiveLog: (obj: AttachPolicyRequest) => any;
+}
+export declare enum ConstraintViolationExceptionReason {
+    ACCOUNT_CANNOT_LEAVE_ORGANIZATION = "ACCOUNT_CANNOT_LEAVE_ORGANIZATION",
+    ACCOUNT_CANNOT_LEAVE_WITHOUT_EULA = "ACCOUNT_CANNOT_LEAVE_WITHOUT_EULA",
+    ACCOUNT_CANNOT_LEAVE_WITHOUT_PHONE_VERIFICATION = "ACCOUNT_CANNOT_LEAVE_WITHOUT_PHONE_VERIFICATION",
+    ACCOUNT_CREATION_RATE_LIMIT_EXCEEDED = "ACCOUNT_CREATION_RATE_LIMIT_EXCEEDED",
+    ACCOUNT_NUMBER_LIMIT_EXCEEDED = "ACCOUNT_NUMBER_LIMIT_EXCEEDED",
+    CANNOT_REGISTER_MASTER_AS_DELEGATED_ADMINISTRATOR = "CANNOT_REGISTER_MASTER_AS_DELEGATED_ADMINISTRATOR",
+    CANNOT_REMOVE_DELEGATED_ADMINISTRATOR_FROM_ORG = "CANNOT_REMOVE_DELEGATED_ADMINISTRATOR_FROM_ORG",
+    CREATE_ORGANIZATION_IN_BILLING_MODE_UNSUPPORTED_REGION = "CREATE_ORGANIZATION_IN_BILLING_MODE_UNSUPPORTED_REGION",
+    DELEGATED_ADMINISTRATOR_EXISTS_FOR_THIS_SERVICE = "DELEGATED_ADMINISTRATOR_EXISTS_FOR_THIS_SERVICE",
+    EMAIL_VERIFICATION_CODE_EXPIRED = "EMAIL_VERIFICATION_CODE_EXPIRED",
+    HANDSHAKE_RATE_LIMIT_EXCEEDED = "HANDSHAKE_RATE_LIMIT_EXCEEDED",
+    MASTER_ACCOUNT_ADDRESS_DOES_NOT_MATCH_MARKETPLACE = "MASTER_ACCOUNT_ADDRESS_DOES_NOT_MATCH_MARKETPLACE",
+    MASTER_ACCOUNT_MISSING_BUSINESS_LICENSE = "MASTER_ACCOUNT_MISSING_BUSINESS_LICENSE",
+    MASTER_ACCOUNT_MISSING_CONTACT_INFO = "MASTER_ACCOUNT_MISSING_CONTACT_INFO",
+    MASTER_ACCOUNT_NOT_GOVCLOUD_ENABLED = "MASTER_ACCOUNT_NOT_GOVCLOUD_ENABLED",
+    MASTER_ACCOUNT_PAYMENT_INSTRUMENT_REQUIRED = "MASTER_ACCOUNT_PAYMENT_INSTRUMENT_REQUIRED",
+    MAX_DELEGATED_ADMINISTRATORS_FOR_SERVICE_LIMIT_EXCEEDED = "MAX_DELEGATED_ADMINISTRATORS_FOR_SERVICE_LIMIT_EXCEEDED",
+    MAX_POLICY_TYPE_ATTACHMENT_LIMIT_EXCEEDED = "MAX_POLICY_TYPE_ATTACHMENT_LIMIT_EXCEEDED",
+    MAX_TAG_LIMIT_EXCEEDED = "MAX_TAG_LIMIT_EXCEEDED",
+    MEMBER_ACCOUNT_PAYMENT_INSTRUMENT_REQUIRED = "MEMBER_ACCOUNT_PAYMENT_INSTRUMENT_REQUIRED",
+    MIN_POLICY_TYPE_ATTACHMENT_LIMIT_EXCEEDED = "MIN_POLICY_TYPE_ATTACHMENT_LIMIT_EXCEEDED",
+    ORGANIZATION_NOT_IN_ALL_FEATURES_MODE = "ORGANIZATION_NOT_IN_ALL_FEATURES_MODE",
+    OU_DEPTH_LIMIT_EXCEEDED = "OU_DEPTH_LIMIT_EXCEEDED",
+    OU_NUMBER_LIMIT_EXCEEDED = "OU_NUMBER_LIMIT_EXCEEDED",
+    POLICY_CONTENT_LIMIT_EXCEEDED = "POLICY_CONTENT_LIMIT_EXCEEDED",
+    POLICY_NUMBER_LIMIT_EXCEEDED = "POLICY_NUMBER_LIMIT_EXCEEDED",
+    TAG_POLICY_VIOLATION = "TAG_POLICY_VIOLATION",
+    WAIT_PERIOD_ACTIVE = "WAIT_PERIOD_ACTIVE"
+}
+
+export declare class ConstraintViolationException extends __BaseException {
+    readonly name: "ConstraintViolationException";
+    readonly $fault: "client";
+    Message?: string;
+    Reason?: ConstraintViolationExceptionReason | string;
+    
+    constructor(opts: __ExceptionOptionType<ConstraintViolationException, __BaseException>);
+}
+
+export declare class DuplicatePolicyAttachmentException extends __BaseException {
+    readonly name: "DuplicatePolicyAttachmentException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<DuplicatePolicyAttachmentException, __BaseException>);
+}
+
+export declare class PolicyChangesInProgressException extends __BaseException {
+    readonly name: "PolicyChangesInProgressException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<PolicyChangesInProgressException, __BaseException>);
+}
+
+export declare class PolicyNotFoundException extends __BaseException {
+    readonly name: "PolicyNotFoundException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<PolicyNotFoundException, __BaseException>);
+}
+
+export declare class PolicyTypeNotEnabledException extends __BaseException {
+    readonly name: "PolicyTypeNotEnabledException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<PolicyTypeNotEnabledException, __BaseException>);
+}
+
+export declare class TargetNotFoundException extends __BaseException {
+    readonly name: "TargetNotFoundException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<TargetNotFoundException, __BaseException>);
+}
+
+export declare class UnsupportedAPIEndpointException extends __BaseException {
+    readonly name: "UnsupportedAPIEndpointException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<UnsupportedAPIEndpointException, __BaseException>);
+}
+export interface CancelHandshakeRequest {
+    
+    HandshakeId: string | undefined;
+}
+export declare namespace CancelHandshakeRequest {
+    
+    const filterSensitiveLog: (obj: CancelHandshakeRequest) => any;
+}
+export declare enum IAMUserAccessToBilling {
+    ALLOW = "ALLOW",
+    DENY = "DENY"
+}
+
+export interface Tag {
+    
+    Key: string | undefined;
+    
+    Value: string | undefined;
+}
+export declare namespace Tag {
+    
+    const filterSensitiveLog: (obj: Tag) => any;
+}
+export interface CreateAccountRequest {
+    
+    Email: string | undefined;
+    
+    AccountName: string | undefined;
+    
+    RoleName?: string;
+    
+    IamUserAccessToBilling?: IAMUserAccessToBilling | string;
+    
+    Tags?: Tag[];
+}
+export declare namespace CreateAccountRequest {
+    
+    const filterSensitiveLog: (obj: CreateAccountRequest) => any;
+}
+export declare enum CreateAccountFailureReason {
+    ACCOUNT_LIMIT_EXCEEDED = "ACCOUNT_LIMIT_EXCEEDED",
+    CONCURRENT_ACCOUNT_MODIFICATION = "CONCURRENT_ACCOUNT_MODIFICATION",
+    EMAIL_ALREADY_EXISTS = "EMAIL_ALREADY_EXISTS",
+    FAILED_BUSINESS_VALIDATION = "FAILED_BUSINESS_VALIDATION",
+    GOVCLOUD_ACCOUNT_ALREADY_EXISTS = "GOVCLOUD_ACCOUNT_ALREADY_EXISTS",
+    INTERNAL_FAILURE = "INTERNAL_FAILURE",
+    INVALID_ADDRESS = "INVALID_ADDRESS",
+    INVALID_EMAIL = "INVALID_EMAIL",
+    INVALID_IDENTITY_FOR_BUSINESS_VALIDATION = "INVALID_IDENTITY_FOR_BUSINESS_VALIDATION",
+    MISSING_BUSINESS_VALIDATION = "MISSING_BUSINESS_VALIDATION",
+    MISSING_PAYMENT_INSTRUMENT = "MISSING_PAYMENT_INSTRUMENT",
+    PENDING_BUSINESS_VALIDATIONv = "PENDING_BUSINESS_VALIDATION",
+    UNKNOWN_BUSINESS_VALIDATION = "UNKNOWN_BUSINESS_VALIDATION"
+}
+export declare enum CreateAccountState {
+    FAILED = "FAILED",
+    IN_PROGRESS = "IN_PROGRESS",
+    SUCCEEDED = "SUCCEEDED"
+}
+
+export interface CreateAccountStatus {
+    
+    Id?: string;
+    
+    AccountName?: string;
+    
+    State?: CreateAccountState | string;
+    
+    RequestedTimestamp?: Date;
+    
+    CompletedTimestamp?: Date;
+    
+    AccountId?: string;
+    
+    GovCloudAccountId?: string;
+    
+    FailureReason?: CreateAccountFailureReason | string;
+}
+export declare namespace CreateAccountStatus {
+    
+    const filterSensitiveLog: (obj: CreateAccountStatus) => any;
+}
+export interface CreateAccountResponse {
+    
+    CreateAccountStatus?: CreateAccountStatus;
+}
+export declare namespace CreateAccountResponse {
+    
+    const filterSensitiveLog: (obj: CreateAccountResponse) => any;
+}
+
+export declare class FinalizingOrganizationException extends __BaseException {
+    readonly name: "FinalizingOrganizationException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<FinalizingOrganizationException, __BaseException>);
+}
+export interface CreateGovCloudAccountRequest {
+    
+    Email: string | undefined;
+    
+    AccountName: string | undefined;
+    
+    RoleName?: string;
+    
+    IamUserAccessToBilling?: IAMUserAccessToBilling | string;
+    
+    Tags?: Tag[];
+}
+export declare namespace CreateGovCloudAccountRequest {
+    
+    const filterSensitiveLog: (obj: CreateGovCloudAccountRequest) => any;
+}
+export interface CreateGovCloudAccountResponse {
+    
+    CreateAccountStatus?: CreateAccountStatus;
+}
+export declare namespace CreateGovCloudAccountResponse {
+    
+    const filterSensitiveLog: (obj: CreateGovCloudAccountResponse) => any;
+}
+export declare enum OrganizationFeatureSet {
+    ALL = "ALL",
+    CONSOLIDATED_BILLING = "CONSOLIDATED_BILLING"
+}
+export interface CreateOrganizationRequest {
+    
+    FeatureSet?: OrganizationFeatureSet | string;
+}
+export declare namespace CreateOrganizationRequest {
+    
+    const filterSensitiveLog: (obj: CreateOrganizationRequest) => any;
+}
+export declare enum PolicyTypeStatus {
+    ENABLED = "ENABLED",
+    PENDING_DISABLE = "PENDING_DISABLE",
+    PENDING_ENABLE = "PENDING_ENABLE"
+}
+export declare enum PolicyType {
+    AISERVICES_OPT_OUT_POLICY = "AISERVICES_OPT_OUT_POLICY",
+    BACKUP_POLICY = "BACKUP_POLICY",
+    SERVICE_CONTROL_POLICY = "SERVICE_CONTROL_POLICY",
+    TAG_POLICY = "TAG_POLICY"
+}
+
+export interface PolicyTypeSummary {
+    
+    Type?: PolicyType | string;
+    
+    Status?: PolicyTypeStatus | string;
+}
+export declare namespace PolicyTypeSummary {
+    
+    const filterSensitiveLog: (obj: PolicyTypeSummary) => any;
+}
+
+export interface Organization {
+    
+    Id?: string;
+    
+    Arn?: string;
+    
+    FeatureSet?: OrganizationFeatureSet | string;
+    
+    MasterAccountArn?: string;
+    
+    MasterAccountId?: string;
+    
+    MasterAccountEmail?: string;
+    
+    AvailablePolicyTypes?: PolicyTypeSummary[];
+}
+export declare namespace Organization {
+    
+    const filterSensitiveLog: (obj: Organization) => any;
+}
+export interface CreateOrganizationResponse {
+    
+    Organization?: Organization;
+}
+export declare namespace CreateOrganizationResponse {
+    
+    const filterSensitiveLog: (obj: CreateOrganizationResponse) => any;
+}
+export interface CreateOrganizationalUnitRequest {
+    
+    ParentId: string | undefined;
+    
+    Name: string | undefined;
+    
+    Tags?: Tag[];
+}
+export declare namespace CreateOrganizationalUnitRequest {
+    
+    const filterSensitiveLog: (obj: CreateOrganizationalUnitRequest) => any;
+}
+
+export interface OrganizationalUnit {
+    
+    Id?: string;
+    
+    Arn?: string;
+    
+    Name?: string;
+}
+export declare namespace OrganizationalUnit {
+    
+    const filterSensitiveLog: (obj: OrganizationalUnit) => any;
+}
+export interface CreateOrganizationalUnitResponse {
+    
+    OrganizationalUnit?: OrganizationalUnit;
+}
+export declare namespace CreateOrganizationalUnitResponse {
+    
+    const filterSensitiveLog: (obj: CreateOrganizationalUnitResponse) => any;
+}
+
+export declare class DuplicateOrganizationalUnitException extends __BaseException {
+    readonly name: "DuplicateOrganizationalUnitException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<DuplicateOrganizationalUnitException, __BaseException>);
+}
+
+export declare class ParentNotFoundException extends __BaseException {
+    readonly name: "ParentNotFoundException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<ParentNotFoundException, __BaseException>);
+}
+export interface CreatePolicyRequest {
+    
+    Content: string | undefined;
+    
+    Description: string | undefined;
+    
+    Name: string | undefined;
+    
+    Type: PolicyType | string | undefined;
+    
+    Tags?: Tag[];
+}
+export declare namespace CreatePolicyRequest {
+    
+    const filterSensitiveLog: (obj: CreatePolicyRequest) => any;
+}
+
+export interface PolicySummary {
+    
+    Id?: string;
+    
+    Arn?: string;
+    
+    Name?: string;
+    
+    Description?: string;
+    
+    Type?: PolicyType | string;
+    
+    AwsManaged?: boolean;
+}
+export declare namespace PolicySummary {
+    
+    const filterSensitiveLog: (obj: PolicySummary) => any;
+}
+
+export interface Policy {
+    
+    PolicySummary?: PolicySummary;
+    
+    Content?: string;
+}
+export declare namespace Policy {
+    
+    const filterSensitiveLog: (obj: Policy) => any;
+}
+export interface CreatePolicyResponse {
+    
+    Policy?: Policy;
+}
+export declare namespace CreatePolicyResponse {
+    
+    const filterSensitiveLog: (obj: CreatePolicyResponse) => any;
+}
+
+export declare class DuplicatePolicyException extends __BaseException {
+    readonly name: "DuplicatePolicyException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<DuplicatePolicyException, __BaseException>);
+}
+
+export declare class MalformedPolicyDocumentException extends __BaseException {
+    readonly name: "MalformedPolicyDocumentException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<MalformedPolicyDocumentException, __BaseException>);
+}
+
+export declare class PolicyTypeNotAvailableForOrganizationException extends __BaseException {
+    readonly name: "PolicyTypeNotAvailableForOrganizationException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<PolicyTypeNotAvailableForOrganizationException, __BaseException>);
+}
+export interface DeclineHandshakeRequest {
+    
+    HandshakeId: string | undefined;
+}
+export declare namespace DeclineHandshakeRequest {
+    
+    const filterSensitiveLog: (obj: DeclineHandshakeRequest) => any;
+}
+
+export declare class OrganizationNotEmptyException extends __BaseException {
+    readonly name: "OrganizationNotEmptyException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<OrganizationNotEmptyException, __BaseException>);
+}
+export interface DeleteOrganizationalUnitRequest {
+    
+    OrganizationalUnitId: string | undefined;
+}
+export declare namespace DeleteOrganizationalUnitRequest {
+    
+    const filterSensitiveLog: (obj: DeleteOrganizationalUnitRequest) => any;
+}
+
+export declare class OrganizationalUnitNotEmptyException extends __BaseException {
+    readonly name: "OrganizationalUnitNotEmptyException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<OrganizationalUnitNotEmptyException, __BaseException>);
+}
+
+export declare class OrganizationalUnitNotFoundException extends __BaseException {
+    readonly name: "OrganizationalUnitNotFoundException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<OrganizationalUnitNotFoundException, __BaseException>);
+}
+export interface DeletePolicyRequest {
+    
+    PolicyId: string | undefined;
+}
+export declare namespace DeletePolicyRequest {
+    
+    const filterSensitiveLog: (obj: DeletePolicyRequest) => any;
+}
+
+export declare class PolicyInUseException extends __BaseException {
+    readonly name: "PolicyInUseException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<PolicyInUseException, __BaseException>);
+}
+export interface DeregisterDelegatedAdministratorRequest {
+    
+    AccountId: string | undefined;
+    
+    ServicePrincipal: string | undefined;
+}
+export declare namespace DeregisterDelegatedAdministratorRequest {
+    
+    const filterSensitiveLog: (obj: DeregisterDelegatedAdministratorRequest) => any;
+}
+export interface DescribeAccountRequest {
+    
+    AccountId: string | undefined;
+}
+export declare namespace DescribeAccountRequest {
+    
+    const filterSensitiveLog: (obj: DescribeAccountRequest) => any;
+}
+export interface DescribeAccountResponse {
+    
+    Account?: Account;
+}
+export declare namespace DescribeAccountResponse {
+    
+    const filterSensitiveLog: (obj: DescribeAccountResponse) => any;
+}
+
+export declare class CreateAccountStatusNotFoundException extends __BaseException {
+    readonly name: "CreateAccountStatusNotFoundException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<CreateAccountStatusNotFoundException, __BaseException>);
+}
+export interface DescribeCreateAccountStatusRequest {
+    
+    CreateAccountRequestId: string | undefined;
+}
+export declare namespace DescribeCreateAccountStatusRequest {
+    
+    const filterSensitiveLog: (obj: DescribeCreateAccountStatusRequest) => any;
+}
+export interface DescribeCreateAccountStatusResponse {
+    
+    CreateAccountStatus?: CreateAccountStatus;
+}
+export declare namespace DescribeCreateAccountStatusResponse {
+    
+    const filterSensitiveLog: (obj: DescribeCreateAccountStatusResponse) => any;
+}
+export declare enum EffectivePolicyType {
+    AISERVICES_OPT_OUT_POLICY = "AISERVICES_OPT_OUT_POLICY",
+    BACKUP_POLICY = "BACKUP_POLICY",
+    TAG_POLICY = "TAG_POLICY"
+}
+export interface DescribeEffectivePolicyRequest {
+    
+    PolicyType: EffectivePolicyType | string | undefined;
+    
+    TargetId?: string;
+}
+export declare namespace DescribeEffectivePolicyRequest {
+    
+    const filterSensitiveLog: (obj: DescribeEffectivePolicyRequest) => any;
+}
+
+export interface EffectivePolicy {
+    
+    PolicyContent?: string;
+    
+    LastUpdatedTimestamp?: Date;
+    
+    TargetId?: string;
+    
+    PolicyType?: EffectivePolicyType | string;
+}
+export declare namespace EffectivePolicy {
+    
+    const filterSensitiveLog: (obj: EffectivePolicy) => any;
+}
+export interface DescribeEffectivePolicyResponse {
+    
+    EffectivePolicy?: EffectivePolicy;
+}
+export declare namespace DescribeEffectivePolicyResponse {
+    
+    const filterSensitiveLog: (obj: DescribeEffectivePolicyResponse) => any;
+}
+
+export declare class EffectivePolicyNotFoundException extends __BaseException {
+    readonly name: "EffectivePolicyNotFoundException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<EffectivePolicyNotFoundException, __BaseException>);
+}
+export interface DescribeHandshakeRequest {
+    
+    HandshakeId: string | undefined;
+}
+export declare namespace DescribeHandshakeRequest {
+    
+    const filterSensitiveLog: (obj: DescribeHandshakeRequest) => any;
+}
+export interface DescribeOrganizationResponse {
+    
+    Organization?: Organization;
+}
+export declare namespace DescribeOrganizationResponse {
+    
+    const filterSensitiveLog: (obj: DescribeOrganizationResponse) => any;
+}
+export interface DescribeOrganizationalUnitRequest {
+    
+    OrganizationalUnitId: string | undefined;
+}
+export declare namespace DescribeOrganizationalUnitRequest {
+    
+    const filterSensitiveLog: (obj: DescribeOrganizationalUnitRequest) => any;
+}
+export interface DescribeOrganizationalUnitResponse {
+    
+    OrganizationalUnit?: OrganizationalUnit;
+}
+export declare namespace DescribeOrganizationalUnitResponse {
+    
+    const filterSensitiveLog: (obj: DescribeOrganizationalUnitResponse) => any;
+}
+export interface DescribePolicyRequest {
+    
+    PolicyId: string | undefined;
+}
+export declare namespace DescribePolicyRequest {
+    
+    const filterSensitiveLog: (obj: DescribePolicyRequest) => any;
+}
+export interface DescribePolicyResponse {
+    
+    Policy?: Policy;
+}
+export declare namespace DescribePolicyResponse {
+    
+    const filterSensitiveLog: (obj: DescribePolicyResponse) => any;
+}
+export interface DetachPolicyRequest {
+    
+    PolicyId: string | undefined;
+    
+    TargetId: string | undefined;
+}
+export declare namespace DetachPolicyRequest {
+    
+    const filterSensitiveLog: (obj: DetachPolicyRequest) => any;
+}
+
+export declare class PolicyNotAttachedException extends __BaseException {
+    readonly name: "PolicyNotAttachedException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<PolicyNotAttachedException, __BaseException>);
+}
+export interface DisableAWSServiceAccessRequest {
+    
+    ServicePrincipal: string | undefined;
+}
+export declare namespace DisableAWSServiceAccessRequest {
+    
+    const filterSensitiveLog: (obj: DisableAWSServiceAccessRequest) => any;
+}
+export interface DisablePolicyTypeRequest {
+    
+    RootId: string | undefined;
+    
+    PolicyType: PolicyType | string | undefined;
+}
+export declare namespace DisablePolicyTypeRequest {
+    
+    const filterSensitiveLog: (obj: DisablePolicyTypeRequest) => any;
+}
+
+export interface Root {
+    
+    Id?: string;
+    
+    Arn?: string;
+    
+    Name?: string;
+    
+    PolicyTypes?: PolicyTypeSummary[];
+}
+export declare namespace Root {
+    
+    const filterSensitiveLog: (obj: Root) => any;
+}
+export interface DisablePolicyTypeResponse {
+    
+    Root?: Root;
+}
+export declare namespace DisablePolicyTypeResponse {
+    
+    const filterSensitiveLog: (obj: DisablePolicyTypeResponse) => any;
+}
+
+export declare class RootNotFoundException extends __BaseException {
+    readonly name: "RootNotFoundException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<RootNotFoundException, __BaseException>);
+}
+export interface EnableAllFeaturesRequest {
+}
+export declare namespace EnableAllFeaturesRequest {
+    
+    const filterSensitiveLog: (obj: EnableAllFeaturesRequest) => any;
+}
+export interface EnableAWSServiceAccessRequest {
+    
+    ServicePrincipal: string | undefined;
+}
+export declare namespace EnableAWSServiceAccessRequest {
+    
+    const filterSensitiveLog: (obj: EnableAWSServiceAccessRequest) => any;
+}
+export interface EnablePolicyTypeRequest {
+    
+    RootId: string | undefined;
+    
+    PolicyType: PolicyType | string | undefined;
+}
+export declare namespace EnablePolicyTypeRequest {
+    
+    const filterSensitiveLog: (obj: EnablePolicyTypeRequest) => any;
+}
+export interface EnablePolicyTypeResponse {
+    
+    Root?: Root;
+}
+export declare namespace EnablePolicyTypeResponse {
+    
+    const filterSensitiveLog: (obj: EnablePolicyTypeResponse) => any;
+}
+
+export declare class PolicyTypeAlreadyEnabledException extends __BaseException {
+    readonly name: "PolicyTypeAlreadyEnabledException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<PolicyTypeAlreadyEnabledException, __BaseException>);
+}
+
+export declare class DuplicateHandshakeException extends __BaseException {
+    readonly name: "DuplicateHandshakeException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<DuplicateHandshakeException, __BaseException>);
+}
+export interface InviteAccountToOrganizationRequest {
+    
+    Target: HandshakeParty | undefined;
+    
+    Notes?: string;
+    
+    Tags?: Tag[];
+}
+export declare namespace InviteAccountToOrganizationRequest {
+    
+    const filterSensitiveLog: (obj: InviteAccountToOrganizationRequest) => any;
+}
+
+export declare class MasterCannotLeaveOrganizationException extends __BaseException {
+    readonly name: "MasterCannotLeaveOrganizationException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<MasterCannotLeaveOrganizationException, __BaseException>);
+}
+export interface ListAccountsRequest {
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace ListAccountsRequest {
+    
+    const filterSensitiveLog: (obj: ListAccountsRequest) => any;
+}
+export interface ListAccountsResponse {
+    
+    Accounts?: Account[];
+    
+    NextToken?: string;
+}
+export declare namespace ListAccountsResponse {
+    
+    const filterSensitiveLog: (obj: ListAccountsResponse) => any;
+}
+export interface ListAccountsForParentRequest {
+    
+    ParentId: string | undefined;
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace ListAccountsForParentRequest {
+    
+    const filterSensitiveLog: (obj: ListAccountsForParentRequest) => any;
+}
+export interface ListAccountsForParentResponse {
+    
+    Accounts?: Account[];
+    
+    NextToken?: string;
+}
+export declare namespace ListAccountsForParentResponse {
+    
+    const filterSensitiveLog: (obj: ListAccountsForParentResponse) => any;
+}
+export interface ListAWSServiceAccessForOrganizationRequest {
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace ListAWSServiceAccessForOrganizationRequest {
+    
+    const filterSensitiveLog: (obj: ListAWSServiceAccessForOrganizationRequest) => any;
+}
+
+export interface EnabledServicePrincipal {
+    
+    ServicePrincipal?: string;
+    
+    DateEnabled?: Date;
+}
+export declare namespace EnabledServicePrincipal {
+    
+    const filterSensitiveLog: (obj: EnabledServicePrincipal) => any;
+}
+export interface ListAWSServiceAccessForOrganizationResponse {
+    
+    EnabledServicePrincipals?: EnabledServicePrincipal[];
+    
+    NextToken?: string;
+}
+export declare namespace ListAWSServiceAccessForOrganizationResponse {
+    
+    const filterSensitiveLog: (obj: ListAWSServiceAccessForOrganizationResponse) => any;
+}
+export declare enum ChildType {
+    ACCOUNT = "ACCOUNT",
+    ORGANIZATIONAL_UNIT = "ORGANIZATIONAL_UNIT"
+}
+export interface ListChildrenRequest {
+    
+    ParentId: string | undefined;
+    
+    ChildType: ChildType | string | undefined;
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace ListChildrenRequest {
+    
+    const filterSensitiveLog: (obj: ListChildrenRequest) => any;
+}
+
+export interface Child {
+    
+    Id?: string;
+    
+    Type?: ChildType | string;
+}
+export declare namespace Child {
+    
+    const filterSensitiveLog: (obj: Child) => any;
+}
+export interface ListChildrenResponse {
+    
+    Children?: Child[];
+    
+    NextToken?: string;
+}
+export declare namespace ListChildrenResponse {
+    
+    const filterSensitiveLog: (obj: ListChildrenResponse) => any;
+}
+export interface ListCreateAccountStatusRequest {
+    
+    States?: (CreateAccountState | string)[];
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace ListCreateAccountStatusRequest {
+    
+    const filterSensitiveLog: (obj: ListCreateAccountStatusRequest) => any;
+}
+export interface ListCreateAccountStatusResponse {
+    
+    CreateAccountStatuses?: CreateAccountStatus[];
+    
+    NextToken?: string;
+}
+export declare namespace ListCreateAccountStatusResponse {
+    
+    const filterSensitiveLog: (obj: ListCreateAccountStatusResponse) => any;
+}
+export interface ListDelegatedAdministratorsRequest {
+    
+    ServicePrincipal?: string;
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace ListDelegatedAdministratorsRequest {
+    
+    const filterSensitiveLog: (obj: ListDelegatedAdministratorsRequest) => any;
+}
+
+export interface DelegatedAdministrator {
+    
+    Id?: string;
+    
+    Arn?: string;
+    
+    Email?: string;
+    
+    Name?: string;
+    
+    Status?: AccountStatus | string;
+    
+    JoinedMethod?: AccountJoinedMethod | string;
+    
+    JoinedTimestamp?: Date;
+    
+    DelegationEnabledDate?: Date;
+}
+export declare namespace DelegatedAdministrator {
+    
+    const filterSensitiveLog: (obj: DelegatedAdministrator) => any;
+}
+export interface ListDelegatedAdministratorsResponse {
+    
+    DelegatedAdministrators?: DelegatedAdministrator[];
+    
+    NextToken?: string;
+}
+export declare namespace ListDelegatedAdministratorsResponse {
+    
+    const filterSensitiveLog: (obj: ListDelegatedAdministratorsResponse) => any;
+}
+export interface ListDelegatedServicesForAccountRequest {
+    
+    AccountId: string | undefined;
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace ListDelegatedServicesForAccountRequest {
+    
+    const filterSensitiveLog: (obj: ListDelegatedServicesForAccountRequest) => any;
+}
+
+export interface DelegatedService {
+    
+    ServicePrincipal?: string;
+    
+    DelegationEnabledDate?: Date;
+}
+export declare namespace DelegatedService {
+    
+    const filterSensitiveLog: (obj: DelegatedService) => any;
+}
+export interface ListDelegatedServicesForAccountResponse {
+    
+    DelegatedServices?: DelegatedService[];
+    
+    NextToken?: string;
+}
+export declare namespace ListDelegatedServicesForAccountResponse {
+    
+    const filterSensitiveLog: (obj: ListDelegatedServicesForAccountResponse) => any;
+}
+
+export interface HandshakeFilter {
+    
+    ActionType?: ActionType | string;
+    
+    ParentHandshakeId?: string;
+}
+export declare namespace HandshakeFilter {
+    
+    const filterSensitiveLog: (obj: HandshakeFilter) => any;
+}
+export interface ListHandshakesForAccountRequest {
+    
+    Filter?: HandshakeFilter;
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace ListHandshakesForAccountRequest {
+    
+    const filterSensitiveLog: (obj: ListHandshakesForAccountRequest) => any;
+}
+export interface ListHandshakesForOrganizationRequest {
+    
+    Filter?: HandshakeFilter;
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace ListHandshakesForOrganizationRequest {
+    
+    const filterSensitiveLog: (obj: ListHandshakesForOrganizationRequest) => any;
+}
+export interface ListOrganizationalUnitsForParentRequest {
+    
+    ParentId: string | undefined;
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace ListOrganizationalUnitsForParentRequest {
+    
+    const filterSensitiveLog: (obj: ListOrganizationalUnitsForParentRequest) => any;
+}
+export interface ListOrganizationalUnitsForParentResponse {
+    
+    OrganizationalUnits?: OrganizationalUnit[];
+    
+    NextToken?: string;
+}
+export declare namespace ListOrganizationalUnitsForParentResponse {
+    
+    const filterSensitiveLog: (obj: ListOrganizationalUnitsForParentResponse) => any;
+}
+
+export declare class ChildNotFoundException extends __BaseException {
+    readonly name: "ChildNotFoundException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<ChildNotFoundException, __BaseException>);
+}
+export interface ListParentsRequest {
+    
+    ChildId: string | undefined;
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace ListParentsRequest {
+    
+    const filterSensitiveLog: (obj: ListParentsRequest) => any;
+}
+export declare enum ParentType {
+    ORGANIZATIONAL_UNIT = "ORGANIZATIONAL_UNIT",
+    ROOT = "ROOT"
+}
+
+export interface Parent {
+    
+    Id?: string;
+    
+    Type?: ParentType | string;
+}
+export declare namespace Parent {
+    
+    const filterSensitiveLog: (obj: Parent) => any;
+}
+export interface ListParentsResponse {
+    
+    Parents?: Parent[];
+    
+    NextToken?: string;
+}
+export declare namespace ListParentsResponse {
+    
+    const filterSensitiveLog: (obj: ListParentsResponse) => any;
+}
+export interface ListPoliciesRequest {
+    
+    Filter: PolicyType | string | undefined;
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace ListPoliciesRequest {
+    
+    const filterSensitiveLog: (obj: ListPoliciesRequest) => any;
+}
+export interface ListPoliciesResponse {
+    
+    Policies?: PolicySummary[];
+    
+    NextToken?: string;
+}
+export declare namespace ListPoliciesResponse {
+    
+    const filterSensitiveLog: (obj: ListPoliciesResponse) => any;
+}
+export interface ListPoliciesForTargetRequest {
+    
+    TargetId: string | undefined;
+    
+    Filter: PolicyType | string | undefined;
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace ListPoliciesForTargetRequest {
+    
+    const filterSensitiveLog: (obj: ListPoliciesForTargetRequest) => any;
+}
+export interface ListPoliciesForTargetResponse {
+    
+    Policies?: PolicySummary[];
+    
+    NextToken?: string;
+}
+export declare namespace ListPoliciesForTargetResponse {
+    
+    const filterSensitiveLog: (obj: ListPoliciesForTargetResponse) => any;
+}
+export interface ListRootsRequest {
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace ListRootsRequest {
+    
+    const filterSensitiveLog: (obj: ListRootsRequest) => any;
+}
+export interface ListRootsResponse {
+    
+    Roots?: Root[];
+    
+    NextToken?: string;
+}
+export declare namespace ListRootsResponse {
+    
+    const filterSensitiveLog: (obj: ListRootsResponse) => any;
+}
+export interface ListTagsForResourceRequest {
+    
+    ResourceId: string | undefined;
+    
+    NextToken?: string;
+}
+export declare namespace ListTagsForResourceRequest {
+    
+    const filterSensitiveLog: (obj: ListTagsForResourceRequest) => any;
+}
+export interface ListTagsForResourceResponse {
+    
+    Tags?: Tag[];
+    
+    NextToken?: string;
+}
+export declare namespace ListTagsForResourceResponse {
+    
+    const filterSensitiveLog: (obj: ListTagsForResourceResponse) => any;
+}
+export interface ListTargetsForPolicyRequest {
+    
+    PolicyId: string | undefined;
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace ListTargetsForPolicyRequest {
+    
+    const filterSensitiveLog: (obj: ListTargetsForPolicyRequest) => any;
+}
+export declare enum TargetType {
+    ACCOUNT = "ACCOUNT",
+    ORGANIZATIONAL_UNIT = "ORGANIZATIONAL_UNIT",
+    ROOT = "ROOT"
+}
+
+export interface PolicyTargetSummary {
+    
+    TargetId?: string;
+    
+    Arn?: string;
+    
+    Name?: string;
+    
+    Type?: TargetType | string;
+}
+export declare namespace PolicyTargetSummary {
+    
+    const filterSensitiveLog: (obj: PolicyTargetSummary) => any;
+}
+export interface ListTargetsForPolicyResponse {
+    
+    Targets?: PolicyTargetSummary[];
+    
+    NextToken?: string;
+}
+export declare namespace ListTargetsForPolicyResponse {
+    
+    const filterSensitiveLog: (obj: ListTargetsForPolicyResponse) => any;
+}
+
+export declare class DestinationParentNotFoundException extends __BaseException {
+    readonly name: "DestinationParentNotFoundException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<DestinationParentNotFoundException, __BaseException>);
+}
+
+export declare class DuplicateAccountException extends __BaseException {
+    readonly name: "DuplicateAccountException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<DuplicateAccountException, __BaseException>);
+}
+export interface MoveAccountRequest {
+    
+    AccountId: string | undefined;
+    
+    SourceParentId: string | undefined;
+    
+    DestinationParentId: string | undefined;
+}
+export declare namespace MoveAccountRequest {
+    
+    const filterSensitiveLog: (obj: MoveAccountRequest) => any;
+}
+
+export declare class SourceParentNotFoundException extends __BaseException {
+    readonly name: "SourceParentNotFoundException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<SourceParentNotFoundException, __BaseException>);
+}
+export interface RegisterDelegatedAdministratorRequest {
+    
+    AccountId: string | undefined;
+    
+    ServicePrincipal: string | undefined;
+}
+export declare namespace RegisterDelegatedAdministratorRequest {
+    
+    const filterSensitiveLog: (obj: RegisterDelegatedAdministratorRequest) => any;
+}
+export interface RemoveAccountFromOrganizationRequest {
+    
+    AccountId: string | undefined;
+}
+export declare namespace RemoveAccountFromOrganizationRequest {
+    
+    const filterSensitiveLog: (obj: RemoveAccountFromOrganizationRequest) => any;
+}
+export interface TagResourceRequest {
+    
+    ResourceId: string | undefined;
+    
+    Tags: Tag[] | undefined;
+}
+export declare namespace TagResourceRequest {
+    
+    const filterSensitiveLog: (obj: TagResourceRequest) => any;
+}
+export interface UntagResourceRequest {
+    
+    ResourceId: string | undefined;
+    
+    TagKeys: string[] | undefined;
+}
+export declare namespace UntagResourceRequest {
+    
+    const filterSensitiveLog: (obj: UntagResourceRequest) => any;
+}
+export interface UpdateOrganizationalUnitRequest {
+    
+    OrganizationalUnitId: string | undefined;
+    
+    Name?: string;
+}
+export declare namespace UpdateOrganizationalUnitRequest {
+    
+    const filterSensitiveLog: (obj: UpdateOrganizationalUnitRequest) => any;
+}
+export interface UpdateOrganizationalUnitResponse {
+    
+    OrganizationalUnit?: OrganizationalUnit;
+}
+export declare namespace UpdateOrganizationalUnitResponse {
+    
+    const filterSensitiveLog: (obj: UpdateOrganizationalUnitResponse) => any;
+}
+export interface UpdatePolicyRequest {
+    
+    PolicyId: string | undefined;
+    
+    Name?: string;
+    
+    Description?: string;
+    
+    Content?: string;
+}
+export declare namespace UpdatePolicyRequest {
+    
+    const filterSensitiveLog: (obj: UpdatePolicyRequest) => any;
+}
+export interface UpdatePolicyResponse {
+    
+    Policy?: Policy;
+}
+export declare namespace UpdatePolicyResponse {
+    
+    const filterSensitiveLog: (obj: UpdatePolicyResponse) => any;
+}
+
+export interface HandshakeResource {
+    
+    Value?: string;
+    
+    Type?: HandshakeResourceType | string;
+    
+    Resources?: HandshakeResource[];
+}
+export declare namespace HandshakeResource {
+    
+    const filterSensitiveLog: (obj: HandshakeResource) => any;
+}
+
+export interface Handshake {
+    
+    Id?: string;
+    
+    Arn?: string;
+    
+    Parties?: HandshakeParty[];
+    
+    State?: HandshakeState | string;
+    
+    RequestedTimestamp?: Date;
+    
+    ExpirationTimestamp?: Date;
+    
+    Action?: ActionType | string;
+    
+    Resources?: HandshakeResource[];
+}
+export declare namespace Handshake {
+    
+    const filterSensitiveLog: (obj: Handshake) => any;
+}
+export interface AcceptHandshakeResponse {
+    
+    Handshake?: Handshake;
+}
+export declare namespace AcceptHandshakeResponse {
+    
+    const filterSensitiveLog: (obj: AcceptHandshakeResponse) => any;
+}
+export interface CancelHandshakeResponse {
+    
+    Handshake?: Handshake;
+}
+export declare namespace CancelHandshakeResponse {
+    
+    const filterSensitiveLog: (obj: CancelHandshakeResponse) => any;
+}
+export interface DeclineHandshakeResponse {
+    
+    Handshake?: Handshake;
+}
+export declare namespace DeclineHandshakeResponse {
+    
+    const filterSensitiveLog: (obj: DeclineHandshakeResponse) => any;
+}
+export interface DescribeHandshakeResponse {
+    
+    Handshake?: Handshake;
+}
+export declare namespace DescribeHandshakeResponse {
+    
+    const filterSensitiveLog: (obj: DescribeHandshakeResponse) => any;
+}
+export interface EnableAllFeaturesResponse {
+    
+    Handshake?: Handshake;
+}
+export declare namespace EnableAllFeaturesResponse {
+    
+    const filterSensitiveLog: (obj: EnableAllFeaturesResponse) => any;
+}
+export interface InviteAccountToOrganizationResponse {
+    
+    Handshake?: Handshake;
+}
+export declare namespace InviteAccountToOrganizationResponse {
+    
+    const filterSensitiveLog: (obj: InviteAccountToOrganizationResponse) => any;
+}
+export interface ListHandshakesForAccountResponse {
+    
+    Handshakes?: Handshake[];
+    
+    NextToken?: string;
+}
+export declare namespace ListHandshakesForAccountResponse {
+    
+    const filterSensitiveLog: (obj: ListHandshakesForAccountResponse) => any;
+}
+export interface ListHandshakesForOrganizationResponse {
+    
+    Handshakes?: Handshake[];
+    
+    NextToken?: string;
+}
+export declare namespace ListHandshakesForOrganizationResponse {
+    
+    const filterSensitiveLog: (obj: ListHandshakesForOrganizationResponse) => any;
+}