@aws-sdk/client-organizations 3.31.0 → 3.35.0

package/dist-types/ts3.4/commands/LeaveOrganizationCommand.d.ts

@@ -0,0 +1,98 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { OrganizationsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../OrganizationsClient";
+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 declare class LeaveOrganizationCommand extends $Command<LeaveOrganizationCommandInput, LeaveOrganizationCommandOutput, OrganizationsClientResolvedConfig> {
+    readonly input: LeaveOrganizationCommandInput;
+    constructor(input: LeaveOrganizationCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: OrganizationsClientResolvedConfig, options?: __HttpHandlerOptions): Handler<LeaveOrganizationCommandInput, LeaveOrganizationCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/ListAWSServiceAccessForOrganizationCommand.d.ts

@@ -0,0 +1,43 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ListAWSServiceAccessForOrganizationRequest, ListAWSServiceAccessForOrganizationResponse } from "../models/models_0";
+import { OrganizationsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../OrganizationsClient";
+export interface ListAWSServiceAccessForOrganizationCommandInput extends ListAWSServiceAccessForOrganizationRequest {
+}
+export interface ListAWSServiceAccessForOrganizationCommandOutput extends ListAWSServiceAccessForOrganizationResponse, __MetadataBearer {
+}
+/**
+ * <p>Returns a list of the AWS services that you enabled to integrate with your
+ *             organization. After a service on this list creates the resources that it requires for
+ *             the integration, it can perform operations on your organization and its accounts.</p>
+ *         <p>For more information about integrating other services with AWS Organizations, including the
+ *             list of services that currently work with 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 or by a member account that is a delegated administrator for an AWS service.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { OrganizationsClient, ListAWSServiceAccessForOrganizationCommand } from "@aws-sdk/client-organizations"; // ES Modules import
+ * // const { OrganizationsClient, ListAWSServiceAccessForOrganizationCommand } = require("@aws-sdk/client-organizations"); // CommonJS import
+ * const client = new OrganizationsClient(config);
+ * const command = new ListAWSServiceAccessForOrganizationCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListAWSServiceAccessForOrganizationCommandInput} for command's `input` shape.
+ * @see {@link ListAWSServiceAccessForOrganizationCommandOutput} for command's `response` shape.
+ * @see {@link OrganizationsClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ListAWSServiceAccessForOrganizationCommand extends $Command<ListAWSServiceAccessForOrganizationCommandInput, ListAWSServiceAccessForOrganizationCommandOutput, OrganizationsClientResolvedConfig> {
+    readonly input: ListAWSServiceAccessForOrganizationCommandInput;
+    constructor(input: ListAWSServiceAccessForOrganizationCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: OrganizationsClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListAWSServiceAccessForOrganizationCommandInput, ListAWSServiceAccessForOrganizationCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/ListAccountsCommand.d.ts

@@ -0,0 +1,46 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ListAccountsRequest, ListAccountsResponse } from "../models/models_0";
+import { OrganizationsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../OrganizationsClient";
+export interface ListAccountsCommandInput extends ListAccountsRequest {
+}
+export interface ListAccountsCommandOutput extends ListAccountsResponse, __MetadataBearer {
+}
+/**
+ * <p>Lists all the accounts in the organization. To request only the accounts in a
+ *             specified root or organizational unit (OU), use the <a>ListAccountsForParent</a> operation instead.</p>
+ *         <note>
+ *             <p>Always check the <code>NextToken</code> response parameter
+ * for a <code>null</code> value when calling a <code>List*</code> operation. These operations can
+ * occasionally return an empty set of results even when there are more results available. The
+ * <code>NextToken</code> response parameter value is <code>null</code>
+ *                <i>only</i>
+ * when there are no more results to display.</p>
+ *          </note>
+ *         <p>This operation can be called only from the organization's
+ * management account or by a member account that is a delegated administrator for an AWS service.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { OrganizationsClient, ListAccountsCommand } from "@aws-sdk/client-organizations"; // ES Modules import
+ * // const { OrganizationsClient, ListAccountsCommand } = require("@aws-sdk/client-organizations"); // CommonJS import
+ * const client = new OrganizationsClient(config);
+ * const command = new ListAccountsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListAccountsCommandInput} for command's `input` shape.
+ * @see {@link ListAccountsCommandOutput} for command's `response` shape.
+ * @see {@link OrganizationsClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ListAccountsCommand extends $Command<ListAccountsCommandInput, ListAccountsCommandOutput, OrganizationsClientResolvedConfig> {
+    readonly input: ListAccountsCommandInput;
+    constructor(input: ListAccountsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: OrganizationsClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListAccountsCommandInput, ListAccountsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/ListAccountsForParentCommand.d.ts

@@ -0,0 +1,49 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ListAccountsForParentRequest, ListAccountsForParentResponse } from "../models/models_0";
+import { OrganizationsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../OrganizationsClient";
+export interface ListAccountsForParentCommandInput extends ListAccountsForParentRequest {
+}
+export interface ListAccountsForParentCommandOutput extends ListAccountsForParentResponse, __MetadataBearer {
+}
+/**
+ * <p>Lists the accounts in an organization that are contained by the specified target root
+ *             or organizational unit (OU). If you specify the root, you get a list of all the accounts
+ *             that aren't in any OU. If you specify an OU, you get a list of all the accounts in only
+ *             that OU and not in any child OUs. To get a list of all accounts in the organization, use
+ *             the <a>ListAccounts</a> operation.</p>
+ *         <note>
+ *             <p>Always check the <code>NextToken</code> response parameter
+ * for a <code>null</code> value when calling a <code>List*</code> operation. These operations can
+ * occasionally return an empty set of results even when there are more results available. The
+ * <code>NextToken</code> response parameter value is <code>null</code>
+ *                <i>only</i>
+ * when there are no more results to display.</p>
+ *          </note>
+ *         <p>This operation can be called only from the organization's
+ * management account or by a member account that is a delegated administrator for an AWS service.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { OrganizationsClient, ListAccountsForParentCommand } from "@aws-sdk/client-organizations"; // ES Modules import
+ * // const { OrganizationsClient, ListAccountsForParentCommand } = require("@aws-sdk/client-organizations"); // CommonJS import
+ * const client = new OrganizationsClient(config);
+ * const command = new ListAccountsForParentCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListAccountsForParentCommandInput} for command's `input` shape.
+ * @see {@link ListAccountsForParentCommandOutput} for command's `response` shape.
+ * @see {@link OrganizationsClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ListAccountsForParentCommand extends $Command<ListAccountsForParentCommandInput, ListAccountsForParentCommandOutput, OrganizationsClientResolvedConfig> {
+    readonly input: ListAccountsForParentCommandInput;
+    constructor(input: ListAccountsForParentCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: OrganizationsClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListAccountsForParentCommandInput, ListAccountsForParentCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/ListChildrenCommand.d.ts

@@ -0,0 +1,47 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ListChildrenRequest, ListChildrenResponse } from "../models/models_0";
+import { OrganizationsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../OrganizationsClient";
+export interface ListChildrenCommandInput extends ListChildrenRequest {
+}
+export interface ListChildrenCommandOutput extends ListChildrenResponse, __MetadataBearer {
+}
+/**
+ * <p>Lists all of the organizational units (OUs) or accounts that are contained in the
+ *             specified parent OU or root. This operation, along with <a>ListParents</a>
+ *             enables you to traverse the tree structure that makes up this root.</p>
+ *         <note>
+ *             <p>Always check the <code>NextToken</code> response parameter
+ * for a <code>null</code> value when calling a <code>List*</code> operation. These operations can
+ * occasionally return an empty set of results even when there are more results available. The
+ * <code>NextToken</code> response parameter value is <code>null</code>
+ *                <i>only</i>
+ * when there are no more results to display.</p>
+ *          </note>
+ *         <p>This operation can be called only from the organization's
+ * management account or by a member account that is a delegated administrator for an AWS service.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { OrganizationsClient, ListChildrenCommand } from "@aws-sdk/client-organizations"; // ES Modules import
+ * // const { OrganizationsClient, ListChildrenCommand } = require("@aws-sdk/client-organizations"); // CommonJS import
+ * const client = new OrganizationsClient(config);
+ * const command = new ListChildrenCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListChildrenCommandInput} for command's `input` shape.
+ * @see {@link ListChildrenCommandOutput} for command's `response` shape.
+ * @see {@link OrganizationsClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ListChildrenCommand extends $Command<ListChildrenCommandInput, ListChildrenCommandOutput, OrganizationsClientResolvedConfig> {
+    readonly input: ListChildrenCommandInput;
+    constructor(input: ListChildrenCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: OrganizationsClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListChildrenCommandInput, ListChildrenCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/ListCreateAccountStatusCommand.d.ts

@@ -0,0 +1,46 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ListCreateAccountStatusRequest, ListCreateAccountStatusResponse } from "../models/models_0";
+import { OrganizationsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../OrganizationsClient";
+export interface ListCreateAccountStatusCommandInput extends ListCreateAccountStatusRequest {
+}
+export interface ListCreateAccountStatusCommandOutput extends ListCreateAccountStatusResponse, __MetadataBearer {
+}
+/**
+ * <p>Lists the account creation requests that match the specified status that is currently
+ *             being tracked for the organization.</p>
+ *         <note>
+ *             <p>Always check the <code>NextToken</code> response parameter
+ * for a <code>null</code> value when calling a <code>List*</code> operation. These operations can
+ * occasionally return an empty set of results even when there are more results available. The
+ * <code>NextToken</code> response parameter value is <code>null</code>
+ *                <i>only</i>
+ * when there are no more results to display.</p>
+ *          </note>
+ *         <p>This operation can be called only from the organization's
+ * management account or by a member account that is a delegated administrator for an AWS service.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { OrganizationsClient, ListCreateAccountStatusCommand } from "@aws-sdk/client-organizations"; // ES Modules import
+ * // const { OrganizationsClient, ListCreateAccountStatusCommand } = require("@aws-sdk/client-organizations"); // CommonJS import
+ * const client = new OrganizationsClient(config);
+ * const command = new ListCreateAccountStatusCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListCreateAccountStatusCommandInput} for command's `input` shape.
+ * @see {@link ListCreateAccountStatusCommandOutput} for command's `response` shape.
+ * @see {@link OrganizationsClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ListCreateAccountStatusCommand extends $Command<ListCreateAccountStatusCommandInput, ListCreateAccountStatusCommandOutput, OrganizationsClientResolvedConfig> {
+    readonly input: ListCreateAccountStatusCommandInput;
+    constructor(input: ListCreateAccountStatusCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: OrganizationsClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListCreateAccountStatusCommandInput, ListCreateAccountStatusCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/ListDelegatedAdministratorsCommand.d.ts

@@ -0,0 +1,38 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ListDelegatedAdministratorsRequest, ListDelegatedAdministratorsResponse } from "../models/models_0";
+import { OrganizationsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../OrganizationsClient";
+export interface ListDelegatedAdministratorsCommandInput extends ListDelegatedAdministratorsRequest {
+}
+export interface ListDelegatedAdministratorsCommandOutput extends ListDelegatedAdministratorsResponse, __MetadataBearer {
+}
+/**
+ * <p>Lists the AWS accounts that are designated as delegated administrators in this
+ *             organization.</p>
+ *         <p>This operation can be called only from the organization's
+ * management account or by a member account that is a delegated administrator for an AWS service.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { OrganizationsClient, ListDelegatedAdministratorsCommand } from "@aws-sdk/client-organizations"; // ES Modules import
+ * // const { OrganizationsClient, ListDelegatedAdministratorsCommand } = require("@aws-sdk/client-organizations"); // CommonJS import
+ * const client = new OrganizationsClient(config);
+ * const command = new ListDelegatedAdministratorsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListDelegatedAdministratorsCommandInput} for command's `input` shape.
+ * @see {@link ListDelegatedAdministratorsCommandOutput} for command's `response` shape.
+ * @see {@link OrganizationsClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ListDelegatedAdministratorsCommand extends $Command<ListDelegatedAdministratorsCommandInput, ListDelegatedAdministratorsCommandOutput, OrganizationsClientResolvedConfig> {
+    readonly input: ListDelegatedAdministratorsCommandInput;
+    constructor(input: ListDelegatedAdministratorsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: OrganizationsClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListDelegatedAdministratorsCommandInput, ListDelegatedAdministratorsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/ListDelegatedServicesForAccountCommand.d.ts

@@ -0,0 +1,38 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ListDelegatedServicesForAccountRequest, ListDelegatedServicesForAccountResponse } from "../models/models_0";
+import { OrganizationsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../OrganizationsClient";
+export interface ListDelegatedServicesForAccountCommandInput extends ListDelegatedServicesForAccountRequest {
+}
+export interface ListDelegatedServicesForAccountCommandOutput extends ListDelegatedServicesForAccountResponse, __MetadataBearer {
+}
+/**
+ * <p>List the AWS services for which the specified account is a delegated
+ *             administrator.</p>
+ *         <p>This operation can be called only from the organization's
+ * management account or by a member account that is a delegated administrator for an AWS service.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { OrganizationsClient, ListDelegatedServicesForAccountCommand } from "@aws-sdk/client-organizations"; // ES Modules import
+ * // const { OrganizationsClient, ListDelegatedServicesForAccountCommand } = require("@aws-sdk/client-organizations"); // CommonJS import
+ * const client = new OrganizationsClient(config);
+ * const command = new ListDelegatedServicesForAccountCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListDelegatedServicesForAccountCommandInput} for command's `input` shape.
+ * @see {@link ListDelegatedServicesForAccountCommandOutput} for command's `response` shape.
+ * @see {@link OrganizationsClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ListDelegatedServicesForAccountCommand extends $Command<ListDelegatedServicesForAccountCommandInput, ListDelegatedServicesForAccountCommandOutput, OrganizationsClientResolvedConfig> {
+    readonly input: ListDelegatedServicesForAccountCommandInput;
+    constructor(input: ListDelegatedServicesForAccountCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: OrganizationsClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListDelegatedServicesForAccountCommandInput, ListDelegatedServicesForAccountCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/ListHandshakesForAccountCommand.d.ts

@@ -0,0 +1,48 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ListHandshakesForAccountRequest, ListHandshakesForAccountResponse } from "../models/models_0";
+import { OrganizationsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../OrganizationsClient";
+export interface ListHandshakesForAccountCommandInput extends ListHandshakesForAccountRequest {
+}
+export interface ListHandshakesForAccountCommandOutput extends ListHandshakesForAccountResponse, __MetadataBearer {
+}
+/**
+ * <p>Lists the current handshakes that are associated with the account of the requesting
+ *             user.</p>
+ *         <p>Handshakes that are <code>ACCEPTED</code>, <code>DECLINED</code>, or
+ *                 <code>CANCELED</code> appear in the results of this API for only 30 days after
+ *             changing to that state. After that, they're deleted and no longer accessible.</p>
+ *         <note>
+ *             <p>Always check the <code>NextToken</code> response parameter
+ * for a <code>null</code> value when calling a <code>List*</code> operation. These operations can
+ * occasionally return an empty set of results even when there are more results available. The
+ * <code>NextToken</code> response parameter value is <code>null</code>
+ *                <i>only</i>
+ * when there are no more results to display.</p>
+ *          </note>
+ *         <p>This operation can be called from any account in the organization.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { OrganizationsClient, ListHandshakesForAccountCommand } from "@aws-sdk/client-organizations"; // ES Modules import
+ * // const { OrganizationsClient, ListHandshakesForAccountCommand } = require("@aws-sdk/client-organizations"); // CommonJS import
+ * const client = new OrganizationsClient(config);
+ * const command = new ListHandshakesForAccountCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListHandshakesForAccountCommandInput} for command's `input` shape.
+ * @see {@link ListHandshakesForAccountCommandOutput} for command's `response` shape.
+ * @see {@link OrganizationsClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ListHandshakesForAccountCommand extends $Command<ListHandshakesForAccountCommandInput, ListHandshakesForAccountCommandOutput, OrganizationsClientResolvedConfig> {
+    readonly input: ListHandshakesForAccountCommandInput;
+    constructor(input: ListHandshakesForAccountCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: OrganizationsClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListHandshakesForAccountCommandInput, ListHandshakesForAccountCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/ListHandshakesForOrganizationCommand.d.ts

@@ -0,0 +1,51 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ListHandshakesForOrganizationRequest, ListHandshakesForOrganizationResponse } from "../models/models_0";
+import { OrganizationsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../OrganizationsClient";
+export interface ListHandshakesForOrganizationCommandInput extends ListHandshakesForOrganizationRequest {
+}
+export interface ListHandshakesForOrganizationCommandOutput extends ListHandshakesForOrganizationResponse, __MetadataBearer {
+}
+/**
+ * <p>Lists the handshakes that are associated with the organization that the requesting
+ *             user is part of. The <code>ListHandshakesForOrganization</code> operation returns a list
+ *             of handshake structures. Each structure contains details and status about a
+ *             handshake.</p>
+ *         <p>Handshakes that are <code>ACCEPTED</code>, <code>DECLINED</code>, or
+ *                 <code>CANCELED</code> appear in the results of this API for only 30 days after
+ *             changing to that state. After that, they're deleted and no longer accessible.</p>
+ *         <note>
+ *             <p>Always check the <code>NextToken</code> response parameter
+ * for a <code>null</code> value when calling a <code>List*</code> operation. These operations can
+ * occasionally return an empty set of results even when there are more results available. The
+ * <code>NextToken</code> response parameter value is <code>null</code>
+ *                <i>only</i>
+ * when there are no more results to display.</p>
+ *          </note>
+ *         <p>This operation can be called only from the organization's
+ * management account or by a member account that is a delegated administrator for an AWS service.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { OrganizationsClient, ListHandshakesForOrganizationCommand } from "@aws-sdk/client-organizations"; // ES Modules import
+ * // const { OrganizationsClient, ListHandshakesForOrganizationCommand } = require("@aws-sdk/client-organizations"); // CommonJS import
+ * const client = new OrganizationsClient(config);
+ * const command = new ListHandshakesForOrganizationCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListHandshakesForOrganizationCommandInput} for command's `input` shape.
+ * @see {@link ListHandshakesForOrganizationCommandOutput} for command's `response` shape.
+ * @see {@link OrganizationsClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ListHandshakesForOrganizationCommand extends $Command<ListHandshakesForOrganizationCommandInput, ListHandshakesForOrganizationCommandOutput, OrganizationsClientResolvedConfig> {
+    readonly input: ListHandshakesForOrganizationCommandInput;
+    constructor(input: ListHandshakesForOrganizationCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: OrganizationsClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListHandshakesForOrganizationCommandInput, ListHandshakesForOrganizationCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/ListOrganizationalUnitsForParentCommand.d.ts

@@ -0,0 +1,45 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ListOrganizationalUnitsForParentRequest, ListOrganizationalUnitsForParentResponse } from "../models/models_0";
+import { OrganizationsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../OrganizationsClient";
+export interface ListOrganizationalUnitsForParentCommandInput extends ListOrganizationalUnitsForParentRequest {
+}
+export interface ListOrganizationalUnitsForParentCommandOutput extends ListOrganizationalUnitsForParentResponse, __MetadataBearer {
+}
+/**
+ * <p>Lists the organizational units (OUs) in a parent organizational unit or root.</p>
+ *         <note>
+ *             <p>Always check the <code>NextToken</code> response parameter
+ * for a <code>null</code> value when calling a <code>List*</code> operation. These operations can
+ * occasionally return an empty set of results even when there are more results available. The
+ * <code>NextToken</code> response parameter value is <code>null</code>
+ *                <i>only</i>
+ * when there are no more results to display.</p>
+ *          </note>
+ *         <p>This operation can be called only from the organization's
+ * management account or by a member account that is a delegated administrator for an AWS service.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { OrganizationsClient, ListOrganizationalUnitsForParentCommand } from "@aws-sdk/client-organizations"; // ES Modules import
+ * // const { OrganizationsClient, ListOrganizationalUnitsForParentCommand } = require("@aws-sdk/client-organizations"); // CommonJS import
+ * const client = new OrganizationsClient(config);
+ * const command = new ListOrganizationalUnitsForParentCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListOrganizationalUnitsForParentCommandInput} for command's `input` shape.
+ * @see {@link ListOrganizationalUnitsForParentCommandOutput} for command's `response` shape.
+ * @see {@link OrganizationsClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ListOrganizationalUnitsForParentCommand extends $Command<ListOrganizationalUnitsForParentCommandInput, ListOrganizationalUnitsForParentCommandOutput, OrganizationsClientResolvedConfig> {
+    readonly input: ListOrganizationalUnitsForParentCommandInput;
+    constructor(input: ListOrganizationalUnitsForParentCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: OrganizationsClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListOrganizationalUnitsForParentCommandInput, ListOrganizationalUnitsForParentCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/ListParentsCommand.d.ts

@@ -0,0 +1,50 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ListParentsRequest, ListParentsResponse } from "../models/models_0";
+import { OrganizationsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../OrganizationsClient";
+export interface ListParentsCommandInput extends ListParentsRequest {
+}
+export interface ListParentsCommandOutput extends ListParentsResponse, __MetadataBearer {
+}
+/**
+ * <p>Lists the root or organizational units (OUs) that serve as the immediate parent of the
+ *             specified child OU or account. This operation, along with <a>ListChildren</a>
+ *             enables you to traverse the tree structure that makes up this root.</p>
+ *         <note>
+ *             <p>Always check the <code>NextToken</code> response parameter
+ * for a <code>null</code> value when calling a <code>List*</code> operation. These operations can
+ * occasionally return an empty set of results even when there are more results available. The
+ * <code>NextToken</code> response parameter value is <code>null</code>
+ *                <i>only</i>
+ * when there are no more results to display.</p>
+ *          </note>
+ *         <p>This operation can be called only from the organization's
+ * management account or by a member account that is a delegated administrator for an AWS service.</p>
+ *         <note>
+ *             <p>In the current release, a child can have only a single parent.</p>
+ *         </note>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { OrganizationsClient, ListParentsCommand } from "@aws-sdk/client-organizations"; // ES Modules import
+ * // const { OrganizationsClient, ListParentsCommand } = require("@aws-sdk/client-organizations"); // CommonJS import
+ * const client = new OrganizationsClient(config);
+ * const command = new ListParentsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListParentsCommandInput} for command's `input` shape.
+ * @see {@link ListParentsCommandOutput} for command's `response` shape.
+ * @see {@link OrganizationsClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ListParentsCommand extends $Command<ListParentsCommandInput, ListParentsCommandOutput, OrganizationsClientResolvedConfig> {
+    readonly input: ListParentsCommandInput;
+    constructor(input: ListParentsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: OrganizationsClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListParentsCommandInput, ListParentsCommandOutput>;
+    private serialize;
+    private deserialize;
+}