@aws-sdk/client-organizations 3.31.0 → 3.35.0

package/src/commands/EnableAWSServiceAccessCommand.ts

@@ -0,0 +1,113 @@
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import {
+  FinalizeHandlerArguments,
+  Handler,
+  HandlerExecutionContext,
+  HttpHandlerOptions as __HttpHandlerOptions,
+  MetadataBearer as __MetadataBearer,
+  MiddlewareStack,
+  SerdeContext as __SerdeContext,
+} from "@aws-sdk/types";
+
+import { EnableAWSServiceAccessRequest } from "../models/models_0";
+import { OrganizationsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../OrganizationsClient";
+import {
+  deserializeAws_json1_1EnableAWSServiceAccessCommand,
+  serializeAws_json1_1EnableAWSServiceAccessCommand,
+} from "../protocols/Aws_json1_1";
+
+export interface EnableAWSServiceAccessCommandInput extends EnableAWSServiceAccessRequest {}
+export interface EnableAWSServiceAccessCommandOutput extends __MetadataBearer {}
+
+/**
+ * <p>Enables the integration of an AWS service (the service that is specified by
+ *                 <code>ServicePrincipal</code>) with AWS Organizations. When you enable integration, you allow
+ *             the specified service to create a <a href="http://docs.aws.amazon.com/IAM/latest/UserGuide/using-service-linked-roles.html">service-linked role</a> in
+ *             all the accounts in your organization. This allows the service to perform operations on
+ *             your behalf in your organization and its accounts.</p>
+ *         <important>
+ *             <p>We recommend that you enable integration between AWS Organizations and the specified AWS
+ *                 service by using the console or commands that are provided by the specified service.
+ *                 Doing so ensures that the service is aware that it can create the resources that are
+ *                 required for the integration. How the service creates those resources in the
+ *                 organization's accounts depends on that service. For more information, see the
+ *                 documentation for the other AWS service.</p>
+ *         </important>
+ *         <p>For more information about enabling services to integrate with AWS Organizations, see <a href="http://docs.aws.amazon.com/organizations/latest/userguide/orgs_integrate_services.html">Integrating AWS Organizations with Other
+ *                 AWS Services</a> in the <i>AWS Organizations User Guide.</i>
+ *          </p>
+ *         <p>This operation can be called only from the organization's management account and only
+ *             if the organization has <a href="http://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_org_support-all-features.html">enabled all
+ *                 features</a>.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { OrganizationsClient, EnableAWSServiceAccessCommand } from "@aws-sdk/client-organizations"; // ES Modules import
+ * // const { OrganizationsClient, EnableAWSServiceAccessCommand } = require("@aws-sdk/client-organizations"); // CommonJS import
+ * const client = new OrganizationsClient(config);
+ * const command = new EnableAWSServiceAccessCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link EnableAWSServiceAccessCommandInput} for command's `input` shape.
+ * @see {@link EnableAWSServiceAccessCommandOutput} for command's `response` shape.
+ * @see {@link OrganizationsClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export class EnableAWSServiceAccessCommand extends $Command<
+  EnableAWSServiceAccessCommandInput,
+  EnableAWSServiceAccessCommandOutput,
+  OrganizationsClientResolvedConfig
+> {
+  // Start section: command_properties
+  // End section: command_properties
+
+  constructor(readonly input: EnableAWSServiceAccessCommandInput) {
+    // Start section: command_constructor
+    super();
+    // End section: command_constructor
+  }
+
+  /**
+   * @internal
+   */
+  resolveMiddleware(
+    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
+    configuration: OrganizationsClientResolvedConfig,
+    options?: __HttpHandlerOptions
+  ): Handler<EnableAWSServiceAccessCommandInput, EnableAWSServiceAccessCommandOutput> {
+    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+
+    const stack = clientStack.concat(this.middlewareStack);
+
+    const { logger } = configuration;
+    const clientName = "OrganizationsClient";
+    const commandName = "EnableAWSServiceAccessCommand";
+    const handlerExecutionContext: HandlerExecutionContext = {
+      logger,
+      clientName,
+      commandName,
+      inputFilterSensitiveLog: EnableAWSServiceAccessRequest.filterSensitiveLog,
+      outputFilterSensitiveLog: (output: any) => output,
+    };
+    const { requestHandler } = configuration;
+    return stack.resolve(
+      (request: FinalizeHandlerArguments<any>) =>
+        requestHandler.handle(request.request as __HttpRequest, options || {}),
+      handlerExecutionContext
+    );
+  }
+
+  private serialize(input: EnableAWSServiceAccessCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
+    return serializeAws_json1_1EnableAWSServiceAccessCommand(input, context);
+  }
+
+  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<EnableAWSServiceAccessCommandOutput> {
+    return deserializeAws_json1_1EnableAWSServiceAccessCommand(output, context);
+  }
+
+  // Start section: command_body_extra
+  // End section: command_body_extra
+}

package/src/commands/EnableAllFeaturesCommand.ts

@@ -0,0 +1,120 @@
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import {
+  FinalizeHandlerArguments,
+  Handler,
+  HandlerExecutionContext,
+  HttpHandlerOptions as __HttpHandlerOptions,
+  MetadataBearer as __MetadataBearer,
+  MiddlewareStack,
+  SerdeContext as __SerdeContext,
+} from "@aws-sdk/types";
+
+import { EnableAllFeaturesRequest, EnableAllFeaturesResponse } from "../models/models_0";
+import { OrganizationsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../OrganizationsClient";
+import {
+  deserializeAws_json1_1EnableAllFeaturesCommand,
+  serializeAws_json1_1EnableAllFeaturesCommand,
+} from "../protocols/Aws_json1_1";
+
+export interface EnableAllFeaturesCommandInput extends EnableAllFeaturesRequest {}
+export interface EnableAllFeaturesCommandOutput extends EnableAllFeaturesResponse, __MetadataBearer {}
+
+/**
+ * <p>Enables all features in an organization. This enables the use of organization policies
+ *             that can restrict the services and actions that can be called in each account. Until you
+ *             enable all features, you have access only to consolidated billing, and you can't use any
+ *             of the advanced account administration features that AWS Organizations supports. For more
+ *             information, see <a href="https://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_org_support-all-features.html">Enabling All Features in Your Organization</a> in the
+ *                 <i>AWS Organizations User Guide.</i>
+ *          </p>
+ *         <important>
+ *             <p>This operation is required only for organizations that were created explicitly
+ *                 with only the consolidated billing features enabled. Calling this operation sends a
+ *                 handshake to every invited account in the organization. The feature set change can
+ *                 be finalized and the additional features enabled only after all administrators in
+ *                 the invited accounts approve the change by accepting the handshake.</p>
+ *         </important>
+ *         <p>After you enable all features, you can separately enable or disable individual policy
+ *             types in a root using <a>EnablePolicyType</a> and <a>DisablePolicyType</a>. To see the status of policy types in a root, use
+ *                 <a>ListRoots</a>.</p>
+ *         <p>After all invited member accounts accept the handshake, you finalize the feature set
+ *             change by accepting the handshake that contains <code>"Action":
+ *                 "ENABLE_ALL_FEATURES"</code>. This completes the change.</p>
+ *         <p>After you enable all features in your organization, the management account in the
+ *             organization can apply policies on all member accounts. These policies can restrict what
+ *             users and even administrators in those accounts can do. The management account can apply
+ *             policies that prevent accounts from leaving the organization. Ensure that your account
+ *             administrators are aware of this.</p>
+ *         <p>This operation can be called only from the organization's management account.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { OrganizationsClient, EnableAllFeaturesCommand } from "@aws-sdk/client-organizations"; // ES Modules import
+ * // const { OrganizationsClient, EnableAllFeaturesCommand } = require("@aws-sdk/client-organizations"); // CommonJS import
+ * const client = new OrganizationsClient(config);
+ * const command = new EnableAllFeaturesCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link EnableAllFeaturesCommandInput} for command's `input` shape.
+ * @see {@link EnableAllFeaturesCommandOutput} for command's `response` shape.
+ * @see {@link OrganizationsClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export class EnableAllFeaturesCommand extends $Command<
+  EnableAllFeaturesCommandInput,
+  EnableAllFeaturesCommandOutput,
+  OrganizationsClientResolvedConfig
+> {
+  // Start section: command_properties
+  // End section: command_properties
+
+  constructor(readonly input: EnableAllFeaturesCommandInput) {
+    // Start section: command_constructor
+    super();
+    // End section: command_constructor
+  }
+
+  /**
+   * @internal
+   */
+  resolveMiddleware(
+    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
+    configuration: OrganizationsClientResolvedConfig,
+    options?: __HttpHandlerOptions
+  ): Handler<EnableAllFeaturesCommandInput, EnableAllFeaturesCommandOutput> {
+    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+
+    const stack = clientStack.concat(this.middlewareStack);
+
+    const { logger } = configuration;
+    const clientName = "OrganizationsClient";
+    const commandName = "EnableAllFeaturesCommand";
+    const handlerExecutionContext: HandlerExecutionContext = {
+      logger,
+      clientName,
+      commandName,
+      inputFilterSensitiveLog: EnableAllFeaturesRequest.filterSensitiveLog,
+      outputFilterSensitiveLog: EnableAllFeaturesResponse.filterSensitiveLog,
+    };
+    const { requestHandler } = configuration;
+    return stack.resolve(
+      (request: FinalizeHandlerArguments<any>) =>
+        requestHandler.handle(request.request as __HttpRequest, options || {}),
+      handlerExecutionContext
+    );
+  }
+
+  private serialize(input: EnableAllFeaturesCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
+    return serializeAws_json1_1EnableAllFeaturesCommand(input, context);
+  }
+
+  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<EnableAllFeaturesCommandOutput> {
+    return deserializeAws_json1_1EnableAllFeaturesCommand(output, context);
+  }
+
+  // Start section: command_body_extra
+  // End section: command_body_extra
+}

package/src/commands/EnablePolicyTypeCommand.ts

@@ -0,0 +1,105 @@
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import {
+  FinalizeHandlerArguments,
+  Handler,
+  HandlerExecutionContext,
+  HttpHandlerOptions as __HttpHandlerOptions,
+  MetadataBearer as __MetadataBearer,
+  MiddlewareStack,
+  SerdeContext as __SerdeContext,
+} from "@aws-sdk/types";
+
+import { EnablePolicyTypeRequest, EnablePolicyTypeResponse } from "../models/models_0";
+import { OrganizationsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../OrganizationsClient";
+import {
+  deserializeAws_json1_1EnablePolicyTypeCommand,
+  serializeAws_json1_1EnablePolicyTypeCommand,
+} from "../protocols/Aws_json1_1";
+
+export interface EnablePolicyTypeCommandInput extends EnablePolicyTypeRequest {}
+export interface EnablePolicyTypeCommandOutput extends EnablePolicyTypeResponse, __MetadataBearer {}
+
+/**
+ * <p>Enables a policy type in a root. After you enable a policy type in a root, you can
+ *             attach policies of that type to the root, any organizational unit (OU), or account in
+ *             that root. You can undo this by using the <a>DisablePolicyType</a>
+ *             operation.</p>
+ *         <p>This is an asynchronous request that AWS performs in the background. AWS
+ *             recommends that you first use <a>ListRoots</a> to see the status of policy
+ *             types for a specified root, and then use this operation.</p>
+ *         <p>This operation can be called only from the organization's management account.</p>
+ *         <p>You can enable a policy type in a root only if that policy type is available in the
+ *             organization. To view the status of available policy types in the organization, use
+ *                 <a>DescribeOrganization</a>.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { OrganizationsClient, EnablePolicyTypeCommand } from "@aws-sdk/client-organizations"; // ES Modules import
+ * // const { OrganizationsClient, EnablePolicyTypeCommand } = require("@aws-sdk/client-organizations"); // CommonJS import
+ * const client = new OrganizationsClient(config);
+ * const command = new EnablePolicyTypeCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link EnablePolicyTypeCommandInput} for command's `input` shape.
+ * @see {@link EnablePolicyTypeCommandOutput} for command's `response` shape.
+ * @see {@link OrganizationsClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export class EnablePolicyTypeCommand extends $Command<
+  EnablePolicyTypeCommandInput,
+  EnablePolicyTypeCommandOutput,
+  OrganizationsClientResolvedConfig
+> {
+  // Start section: command_properties
+  // End section: command_properties
+
+  constructor(readonly input: EnablePolicyTypeCommandInput) {
+    // Start section: command_constructor
+    super();
+    // End section: command_constructor
+  }
+
+  /**
+   * @internal
+   */
+  resolveMiddleware(
+    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
+    configuration: OrganizationsClientResolvedConfig,
+    options?: __HttpHandlerOptions
+  ): Handler<EnablePolicyTypeCommandInput, EnablePolicyTypeCommandOutput> {
+    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+
+    const stack = clientStack.concat(this.middlewareStack);
+
+    const { logger } = configuration;
+    const clientName = "OrganizationsClient";
+    const commandName = "EnablePolicyTypeCommand";
+    const handlerExecutionContext: HandlerExecutionContext = {
+      logger,
+      clientName,
+      commandName,
+      inputFilterSensitiveLog: EnablePolicyTypeRequest.filterSensitiveLog,
+      outputFilterSensitiveLog: EnablePolicyTypeResponse.filterSensitiveLog,
+    };
+    const { requestHandler } = configuration;
+    return stack.resolve(
+      (request: FinalizeHandlerArguments<any>) =>
+        requestHandler.handle(request.request as __HttpRequest, options || {}),
+      handlerExecutionContext
+    );
+  }
+
+  private serialize(input: EnablePolicyTypeCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
+    return serializeAws_json1_1EnablePolicyTypeCommand(input, context);
+  }
+
+  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<EnablePolicyTypeCommandOutput> {
+    return deserializeAws_json1_1EnablePolicyTypeCommand(output, context);
+  }
+
+  // Start section: command_body_extra
+  // End section: command_body_extra
+}

package/src/commands/InviteAccountToOrganizationCommand.ts

@@ -0,0 +1,125 @@
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import {
+  FinalizeHandlerArguments,
+  Handler,
+  HandlerExecutionContext,
+  HttpHandlerOptions as __HttpHandlerOptions,
+  MetadataBearer as __MetadataBearer,
+  MiddlewareStack,
+  SerdeContext as __SerdeContext,
+} from "@aws-sdk/types";
+
+import { InviteAccountToOrganizationRequest, InviteAccountToOrganizationResponse } from "../models/models_0";
+import { OrganizationsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../OrganizationsClient";
+import {
+  deserializeAws_json1_1InviteAccountToOrganizationCommand,
+  serializeAws_json1_1InviteAccountToOrganizationCommand,
+} from "../protocols/Aws_json1_1";
+
+export interface InviteAccountToOrganizationCommandInput extends InviteAccountToOrganizationRequest {}
+export interface InviteAccountToOrganizationCommandOutput
+  extends InviteAccountToOrganizationResponse,
+    __MetadataBearer {}
+
+/**
+ * <p>Sends an invitation to another account to join your organization as a member account.
+ *             AWS Organizations sends email on your behalf to the email address that is associated with the
+ *             other account's owner. The invitation is implemented as a <a>Handshake</a>
+ *             whose details are in the response.</p>
+ *         <important>
+ *             <ul>
+ *                <li>
+ *                     <p>You can invite AWS accounts only from the same seller as the management
+ *                         account. For example, if your organization's management account was created
+ *                         by Amazon Internet Services Pvt. Ltd (AISPL), an AWS seller in India, you
+ *                         can invite only other AISPL accounts to your organization. You can't combine
+ *                         accounts from AISPL and AWS or from any other AWS seller. For more
+ *                         information, see <a href="http://docs.aws.amazon.com/awsaccountbilling/latest/aboutv2/useconsolidatedbilliing-India.html">Consolidated
+ *                             Billing in India</a>.</p>
+ *                 </li>
+ *                <li>
+ *                     <p>If you receive an exception that indicates that you exceeded your account
+ *                         limits for the organization or that the operation failed because your
+ *                         organization is still initializing, wait one hour and then try again. If the
+ *                         error persists after an hour, contact <a href="https://console.aws.amazon.com/support/home#/">AWS Support</a>.</p>
+ *                 </li>
+ *             </ul>
+ *         </important>
+ *         <p>If the request includes tags, then the requester must have the
+ *                 <code>organizations:TagResource</code> permission.</p>
+ *         <p>This operation can be called only from the organization's management account.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { OrganizationsClient, InviteAccountToOrganizationCommand } from "@aws-sdk/client-organizations"; // ES Modules import
+ * // const { OrganizationsClient, InviteAccountToOrganizationCommand } = require("@aws-sdk/client-organizations"); // CommonJS import
+ * const client = new OrganizationsClient(config);
+ * const command = new InviteAccountToOrganizationCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link InviteAccountToOrganizationCommandInput} for command's `input` shape.
+ * @see {@link InviteAccountToOrganizationCommandOutput} for command's `response` shape.
+ * @see {@link OrganizationsClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export class InviteAccountToOrganizationCommand extends $Command<
+  InviteAccountToOrganizationCommandInput,
+  InviteAccountToOrganizationCommandOutput,
+  OrganizationsClientResolvedConfig
+> {
+  // Start section: command_properties
+  // End section: command_properties
+
+  constructor(readonly input: InviteAccountToOrganizationCommandInput) {
+    // Start section: command_constructor
+    super();
+    // End section: command_constructor
+  }
+
+  /**
+   * @internal
+   */
+  resolveMiddleware(
+    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
+    configuration: OrganizationsClientResolvedConfig,
+    options?: __HttpHandlerOptions
+  ): Handler<InviteAccountToOrganizationCommandInput, InviteAccountToOrganizationCommandOutput> {
+    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+
+    const stack = clientStack.concat(this.middlewareStack);
+
+    const { logger } = configuration;
+    const clientName = "OrganizationsClient";
+    const commandName = "InviteAccountToOrganizationCommand";
+    const handlerExecutionContext: HandlerExecutionContext = {
+      logger,
+      clientName,
+      commandName,
+      inputFilterSensitiveLog: InviteAccountToOrganizationRequest.filterSensitiveLog,
+      outputFilterSensitiveLog: InviteAccountToOrganizationResponse.filterSensitiveLog,
+    };
+    const { requestHandler } = configuration;
+    return stack.resolve(
+      (request: FinalizeHandlerArguments<any>) =>
+        requestHandler.handle(request.request as __HttpRequest, options || {}),
+      handlerExecutionContext
+    );
+  }
+
+  private serialize(input: InviteAccountToOrganizationCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
+    return serializeAws_json1_1InviteAccountToOrganizationCommand(input, context);
+  }
+
+  private deserialize(
+    output: __HttpResponse,
+    context: __SerdeContext
+  ): Promise<InviteAccountToOrganizationCommandOutput> {
+    return deserializeAws_json1_1InviteAccountToOrganizationCommand(output, context);
+  }
+
+  // Start section: command_body_extra
+  // End section: command_body_extra
+}

package/src/commands/LeaveOrganizationCommand.ts

@@ -0,0 +1,158 @@
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import {
+  FinalizeHandlerArguments,
+  Handler,
+  HandlerExecutionContext,
+  HttpHandlerOptions as __HttpHandlerOptions,
+  MetadataBearer as __MetadataBearer,
+  MiddlewareStack,
+  SerdeContext as __SerdeContext,
+} from "@aws-sdk/types";
+
+import { OrganizationsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../OrganizationsClient";
+import {
+  deserializeAws_json1_1LeaveOrganizationCommand,
+  serializeAws_json1_1LeaveOrganizationCommand,
+} from "../protocols/Aws_json1_1";
+
+export interface LeaveOrganizationCommandInput {}
+export interface LeaveOrganizationCommandOutput extends __MetadataBearer {}
+
+/**
+ * <p>Removes a member account from its parent organization. This version of the operation
+ *             is performed by the account that wants to leave. To remove a member account as a user in
+ *             the management account, use <a>RemoveAccountFromOrganization</a>
+ *             instead.</p>
+ *         <p>This operation can be called only from a member account in the organization.</p>
+ *         <important>
+ *             <ul>
+ *                <li>
+ *                     <p>The management account in an organization with all features enabled can
+ *                         set service control policies (SCPs) that can restrict what administrators of
+ *                         member accounts can do. This includes preventing them from successfully
+ *                         calling <code>LeaveOrganization</code> and leaving the organization.</p>
+ *                 </li>
+ *                <li>
+ *                     <p>You can leave an organization as a member account only if the account is
+ *                         configured with the information required to operate as a standalone account.
+ *                         When you create an account in an organization using the AWS Organizations console,
+ *                         API, or CLI commands, the information required of standalone accounts is
+ *                             <i>not</i> automatically collected. For each account that
+ *                         you want to make standalone, you must perform the following steps. If any of
+ *                         the steps are already completed for this account, that step doesn't
+ *                         appear.</p>
+ *                     <ul>
+ *                      <li>
+ *                             <p>Choose a support plan</p>
+ *                         </li>
+ *                      <li>
+ *                             <p>Provide and verify the required contact information</p>
+ *                         </li>
+ *                      <li>
+ *                             <p>Provide a current payment method</p>
+ *                         </li>
+ *                   </ul>
+ *                     <p>AWS uses the payment method to charge for any billable (not free tier)
+ *                         AWS activity that occurs while the account isn't attached to an
+ *                         organization. Follow the steps at <a href="http://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_accounts_remove.html#leave-without-all-info"> To leave an organization when all required account information has not
+ *                             yet been provided</a> in the
+ *                         <i>AWS Organizations User Guide.</i>
+ *                   </p>
+ *                 </li>
+ *                <li>
+ *                     <p>The account that you want to leave must not be a delegated administrator
+ *                         account for any AWS service enabled for your organization. If the account
+ *                         is a delegated administrator, you must first change the delegated
+ *                         administrator account to another account that is remaining in the
+ *                         organization.</p>
+ *                 </li>
+ *                <li>
+ *                     <p>You can leave an organization only after you enable IAM user access to
+ *                         billing in your account. For more information, see <a href="http://docs.aws.amazon.com/awsaccountbilling/latest/aboutv2/grantaccess.html#ControllingAccessWebsite-Activate">Activating Access to the Billing and Cost Management Console</a> in
+ *                         the <i>AWS Billing and Cost Management User Guide.</i>
+ *                   </p>
+ *                 </li>
+ *                <li>
+ *                     <p>After the account leaves the organization, all tags that were attached to
+ *                         the account object in the organization are deleted. AWS accounts outside
+ *                         of an organization do not support tags.</p>
+ *                 </li>
+ *                <li>
+ *                     <p>A newly created account has a waiting period before it can be removed from
+ *                         its organization. If you get an error that indicates that a wait period is
+ *                         required, then try again in a few days.</p>
+ *                 </li>
+ *             </ul>
+ *         </important>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { OrganizationsClient, LeaveOrganizationCommand } from "@aws-sdk/client-organizations"; // ES Modules import
+ * // const { OrganizationsClient, LeaveOrganizationCommand } = require("@aws-sdk/client-organizations"); // CommonJS import
+ * const client = new OrganizationsClient(config);
+ * const command = new LeaveOrganizationCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link LeaveOrganizationCommandInput} for command's `input` shape.
+ * @see {@link LeaveOrganizationCommandOutput} for command's `response` shape.
+ * @see {@link OrganizationsClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export class LeaveOrganizationCommand extends $Command<
+  LeaveOrganizationCommandInput,
+  LeaveOrganizationCommandOutput,
+  OrganizationsClientResolvedConfig
+> {
+  // Start section: command_properties
+  // End section: command_properties
+
+  constructor(readonly input: LeaveOrganizationCommandInput) {
+    // Start section: command_constructor
+    super();
+    // End section: command_constructor
+  }
+
+  /**
+   * @internal
+   */
+  resolveMiddleware(
+    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
+    configuration: OrganizationsClientResolvedConfig,
+    options?: __HttpHandlerOptions
+  ): Handler<LeaveOrganizationCommandInput, LeaveOrganizationCommandOutput> {
+    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+
+    const stack = clientStack.concat(this.middlewareStack);
+
+    const { logger } = configuration;
+    const clientName = "OrganizationsClient";
+    const commandName = "LeaveOrganizationCommand";
+    const handlerExecutionContext: HandlerExecutionContext = {
+      logger,
+      clientName,
+      commandName,
+      inputFilterSensitiveLog: (input: any) => input,
+      outputFilterSensitiveLog: (output: any) => output,
+    };
+    const { requestHandler } = configuration;
+    return stack.resolve(
+      (request: FinalizeHandlerArguments<any>) =>
+        requestHandler.handle(request.request as __HttpRequest, options || {}),
+      handlerExecutionContext
+    );
+  }
+
+  private serialize(input: LeaveOrganizationCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
+    return serializeAws_json1_1LeaveOrganizationCommand(input, context);
+  }
+
+  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<LeaveOrganizationCommandOutput> {
+    return deserializeAws_json1_1LeaveOrganizationCommand(output, context);
+  }
+
+  // Start section: command_body_extra
+  // End section: command_body_extra
+}