@aws-sdk/client-organizations 3.31.0 → 3.35.0

package/commands/EnableAWSServiceAccessCommand.ts

@@ -1,112 +0,0 @@
-import { OrganizationsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../OrganizationsClient";
-import { EnableAWSServiceAccessRequest } from "../models/models_0";
-import {
-  deserializeAws_json1_1EnableAWSServiceAccessCommand,
-  serializeAws_json1_1EnableAWSServiceAccessCommand,
-} from "../protocols/Aws_json1_1";
-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,
-  MiddlewareStack,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  SerdeContext as __SerdeContext,
-} from "@aws-sdk/types";
-
-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/commands/EnableAllFeaturesCommand.ts

@@ -1,119 +0,0 @@
-import { OrganizationsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../OrganizationsClient";
-import { EnableAllFeaturesRequest, EnableAllFeaturesResponse } from "../models/models_0";
-import {
-  deserializeAws_json1_1EnableAllFeaturesCommand,
-  serializeAws_json1_1EnableAllFeaturesCommand,
-} from "../protocols/Aws_json1_1";
-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,
-  MiddlewareStack,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  SerdeContext as __SerdeContext,
-} from "@aws-sdk/types";
-
-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/commands/EnablePolicyTypeCommand.ts

@@ -1,104 +0,0 @@
-import { OrganizationsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../OrganizationsClient";
-import { EnablePolicyTypeRequest, EnablePolicyTypeResponse } from "../models/models_0";
-import {
-  deserializeAws_json1_1EnablePolicyTypeCommand,
-  serializeAws_json1_1EnablePolicyTypeCommand,
-} from "../protocols/Aws_json1_1";
-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,
-  MiddlewareStack,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  SerdeContext as __SerdeContext,
-} from "@aws-sdk/types";
-
-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/commands/InviteAccountToOrganizationCommand.ts

@@ -1,124 +0,0 @@
-import { OrganizationsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../OrganizationsClient";
-import { InviteAccountToOrganizationRequest, InviteAccountToOrganizationResponse } from "../models/models_0";
-import {
-  deserializeAws_json1_1InviteAccountToOrganizationCommand,
-  serializeAws_json1_1InviteAccountToOrganizationCommand,
-} from "../protocols/Aws_json1_1";
-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,
-  MiddlewareStack,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  SerdeContext as __SerdeContext,
-} from "@aws-sdk/types";
-
-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/commands/LeaveOrganizationCommand.ts

@@ -1,157 +0,0 @@
-import { OrganizationsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../OrganizationsClient";
-import {
-  deserializeAws_json1_1LeaveOrganizationCommand,
-  serializeAws_json1_1LeaveOrganizationCommand,
-} from "../protocols/Aws_json1_1";
-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,
-  MiddlewareStack,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  SerdeContext as __SerdeContext,
-} from "@aws-sdk/types";
-
-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
-}