### StartTestCaseExecutionCommand Example

Source: https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/connect/command/StartTestCaseExecutionCommand

Demonstrates how to start a test case execution using the ConnectClient. This example shows the basic setup with ES Modules import, client configuration, and the required input parameters for the command.

```javascript
import {
  ConnectClient,
  StartTestCaseExecutionCommand,
} from "@aws-sdk/client-connect"; // ES Modules import
// const { ConnectClient, StartTestCaseExecutionCommand } = require("@aws-sdk/client-connect"); // CommonJS import
// import type { ConnectClientConfig } from "@aws-sdk/client-connect";
const config = {}; // type is ConnectClientConfig
const client = new ConnectClient(config);
const input = {
  // StartTestCaseExecutionRequest
  InstanceId: "STRING_VALUE", // required
  TestCaseId: "STRING_VALUE", // required
  ClientToken: "STRING_VALUE",
};
const command = new StartTestCaseExecutionCommand(input);
const response = await client.send(command);
// {
//   // StartTestCaseExecutionResponse
//   TestCaseExecutionId: "STRING_VALUE",
//   TestCaseId: "STRING_VALUE",
//   Status: "INITIATED" || "PASSED" || "FAILED" || "IN_PROGRESS" || "STOPPED",
// };

```

--------------------------------

### Start Retraining Scheduler

Source: https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/lookoutequipment/command/StartRetrainingSchedulerCommand

Starts a retraining scheduler for a specified model. This example uses ES Modules import. Ensure you have the necessary configuration and client setup.

```javascript
import { LookoutEquipmentClient, StartRetrainingSchedulerCommand } from "@aws-sdk/client-lookoutequipment"; // ES Modules import
// const { LookoutEquipmentClient, StartRetrainingSchedulerCommand } = require("@aws-sdk/client-lookoutequipment"); // CommonJS import
// import type { LookoutEquipmentClientConfig } from "@aws-sdk/client-lookoutequipment";
const config = {}; // type is LookoutEquipmentClientConfig
const client = new LookoutEquipmentClient(config);
const input = { // StartRetrainingSchedulerRequest
  ModelName: "STRING_VALUE", // required
};
const command = new StartRetrainingSchedulerCommand(input);
const response = await client.send(command);
// { // StartRetrainingSchedulerResponse
//   ModelName: "STRING_VALUE",
//   ModelArn: "STRING_VALUE",
//   Status: "PENDING" || "RUNNING" || "STOPPING" || "STOPPED",
// };

```

--------------------------------

### StartQAppSessionCommand Example

Source: https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/qapps/command/StartQAppSessionCommand

Demonstrates how to use the StartQAppSessionCommand with a bare-bones client. This example shows the necessary imports, client configuration, input parameters, and how to send the command to start a Q App session.

```javascript
import {
  QAppsClient,
  StartQAppSessionCommand
} from "@aws-sdk/client-qapps"; // ES Modules import
// const { QAppsClient, StartQAppSessionCommand } = require("@aws-sdk/client-qapps"); // CommonJS import
// import type { QAppsClientConfig } from "@aws-sdk/client-qapps";
const config = {}; // type is QAppsClientConfig
const client = new QAppsClient(config);
const input = {
  // StartQAppSessionInput
  instanceId: "STRING_VALUE", // required
  appId: "STRING_VALUE", // required
  appVersion: Number("int"), // required
  initialValues: [
    // CardValueList
    {
      // CardValue
      cardId: "STRING_VALUE", // required
      value: "STRING_VALUE", // required
      submissionMutation: {
        // SubmissionMutation
        submissionId: "STRING_VALUE", // required
        mutationType: "edit" || "delete" || "add", // required
      },
    },
  ],
  sessionId: "STRING_VALUE",
  tags: {
    // TagMap
    "<keys>": "STRING_VALUE",
  },
};
const command = new StartQAppSessionCommand(input);
const response = await client.send(command);
// { // StartQAppSessionOutput
//   sessionId: "STRING_VALUE", // required
//   sessionArn: "STRING_VALUE", // required
// };

```

--------------------------------

### StartDeviceDiscoveryCommand Example

Source: https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/iot-managed-integrations/command/StartDeviceDiscoveryCommand

Demonstrates how to use the StartDeviceDiscoveryCommand with a bare-bones client. This example shows the necessary imports and how to construct the command with various input parameters.

```javascript
import { IoTManagedIntegrationsClient, StartDeviceDiscoveryCommand } from "@aws-sdk/client-iot-managed-integrations"; // ES Modules import
// const { IoTManagedIntegrationsClient, StartDeviceDiscoveryCommand } = require("@aws-sdk/client-iot-managed-integrations"); // CommonJS import
// import type { IoTManagedIntegrationsClientConfig } from "@aws-sdk/client-iot-managed-integrations";
const config = {}; // type is IoTManagedIntegrationsClientConfig
const client = new IoTManagedIntegrationsClient(config);
const input = { // StartDeviceDiscoveryRequest
  DiscoveryType: "ZWAVE" || "ZIGBEE" || "CLOUD" || "CUSTOM" || "CONTROLLER_CAPABILITY_REDISCOVERY", // required
  CustomProtocolDetail: { // CustomProtocolDetail
    "<keys>": "STRING_VALUE",
  },
  ControllerIdentifier: "STRING_VALUE",
  ConnectorAssociationIdentifier: "STRING_VALUE",
  AccountAssociationId: "STRING_VALUE",
  AuthenticationMaterial: "STRING_VALUE",
  AuthenticationMaterialType: "ZWAVE_INSTALL_CODE",
  ClientToken: "STRING_VALUE",
  Tags: { // TagsMap
    "<keys>": "STRING_VALUE",
  },
  ConnectorDeviceIdList: [
    "STRING_VALUE",
  ],
  Protocol: "ZWAVE" || "ZIGBEE" || "CUSTOM",
  EndDeviceIdentifier: "STRING_VALUE",
};
const command = new StartDeviceDiscoveryCommand(input);
const response = await client.send(command);
// { // StartDeviceDiscoveryResponse
//   Id: "STRING_VALUE",
//   StartedAt: new Date("TIMESTAMP"),
// };

```

--------------------------------

### StartRouterInputCommand Example

Source: https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/mediaconnect/command/StartRouterInputCommand

This example demonstrates how to start a router input by providing its ARN to the StartRouterInputCommand. It shows the client setup, command creation, and sending the command to the MediaConnect client.

```APIDOC
## StartRouterInputCommand

### Description
Starts a router input in AWS Elemental MediaConnect.

### Method
POST (Implicit, as it's an SDK command that modifies state)

### Endpoint
(Not applicable for SDK commands, but conceptually related to MediaConnect service)

### Parameters
#### Path Parameters
(None)

#### Query Parameters
(None)

#### Request Body
- **Arn** (string) - Required - The Amazon Resource Name (ARN) of the router input that you want to start.

### Request Example
```javascript
import {
  MediaConnectClient,
  StartRouterInputCommand,
} from "@aws-sdk/client-mediaconnect";

const config = {};
const client = new MediaConnectClient(config);
const input = {
  Arn: "STRING_VALUE", // required
};
const command = new StartRouterInputCommand(input);
const response = await client.send(command);
```

### Response
#### Success Response (200)
- **Arn** (string) - The Amazon Resource Name (ARN) of the router input.
- **Name** (string) - The name of the router input.
- **State** (string) - The current state of the router input. Possible values: "CREATING", "STANDBY", "STARTING", "ACTIVE", "STOPPING", "DELETING", "UPDATING", "ERROR", "RECOVERING", "MIGRATING".
- **MaintenanceScheduleType** (string) - The type of maintenance schedule.
- **MaintenanceSchedule** (object) - Details about the maintenance schedule.
  - **Window** (object) - Information about the maintenance window.
    - **Start** (Date) - The start of the maintenance window.
    - **End** (Date) - The end of the maintenance window.
    - **ScheduledTime** (Date) - The scheduled time for maintenance.

#### Response Example
```json
{
  "Arn": "STRING_VALUE",
  "Name": "STRING_VALUE",
  "State": "STARTING",
  "MaintenanceScheduleType": "WINDOW",
  "MaintenanceSchedule": {
    "Window": {
      "Start": "TIMESTAMP",
      "End": "TIMESTAMP",
      "ScheduledTime": "TIMESTAMP"
    }
  }
}
```
```

--------------------------------

### StartApplicationCommand Example

Source: https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/m2/command/StartApplicationCommand

This example demonstrates how to use the StartApplicationCommand to start an application. It includes importing the necessary modules, configuring the client, defining the input parameters, creating the command, and sending the command to the client.

```APIDOC
## StartApplicationCommand

### Description
Starts an application that is currently stopped.

### Method
POST (Implicit, as it's an SDK command)

### Endpoint
(Not directly applicable for SDK commands, but conceptually related to the M2 service)

### Parameters
#### Input Parameters
- **applicationId** (string) - Required - The unique identifier of the application you want to start.

### Request Example
```javascript
import { M2Client, StartApplicationCommand } from "@aws-sdk/client-m2";

const config = {}; 
const client = new M2Client(config);
const input = {
  applicationId: "STRING_VALUE", // required
};
const command = new StartApplicationCommand(input);
const response = await client.send(command);
// response is an empty object {} for success
```

### Response
#### Success Response (200)
- **$metadata** (ResponseMetadata) - Metadata pertaining to this request.

### Throws
- **AccessDeniedException** (client) - The account or role doesn't have the right permissions to make the request.
- **ConflictException** (client) - The parameters provided in the request conflict with existing resources.
- **InternalServerException** (server) - An unexpected error occurred during the processing of the request.
- **ResourceNotFoundException** (client) - The specified resource was not found.
- **ThrottlingException** (client) - The number of requests made exceeds the limit.
- **ValidationException** (client) - One or more parameters provided in the request is not valid.
- **M2ServiceException** - Base exception class for all service exceptions from M2 service.
```

--------------------------------

### Start CIS Session

Source: https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/inspector2/command/StartCisSessionCommand

Starts a CIS session for a given scan job ID and session token. This is a bare-bones example demonstrating the essential client and command setup.

```javascript
import {
  Inspector2Client,
  StartCisSessionCommand,
} from "@aws-sdk/client-inspector2"; // ES Modules import
// const { Inspector2Client, StartCisSessionCommand } = require("@aws-sdk/client-inspector2"); // CommonJS import
// import type { Inspector2ClientConfig } from "@aws-sdk/client-inspector2";
const config = {}; // type is Inspector2ClientConfig
const client = new Inspector2Client(config);
const input = { // StartCisSessionRequest
  scanJobId: "STRING_VALUE", // required
  message: {
    // StartCisSessionMessage
    sessionToken: "STRING_VALUE", // required
  },
};
const command = new StartCisSessionCommand(input);
const response = await client.send(command);
// {};
```

--------------------------------

### DescribeKeyRegistrationCommand Example

Source: https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/quicksight/command/DescribeKeyRegistrationCommand

Use a bare-bones client and the command you need to make an API call. This example demonstrates how to import the necessary components, configure the client, create the command with input parameters, and send the command to the QuickSight service. It also shows the structure of the expected response.

```javascript
import { QuickSightClient, DescribeKeyRegistrationCommand } from "@aws-sdk/client-quicksight"; // ES Modules import
// const { QuickSightClient, DescribeKeyRegistrationCommand } = require("@aws-sdk/client-quicksight"); // CommonJS import
// import type { QuickSightClientConfig } from "@aws-sdk/client-quicksight";
const config = {}; // type is QuickSightClientConfig
const client = new QuickSightClient(config);
const input = { // DescribeKeyRegistrationRequest
  AwsAccountId: "STRING_VALUE", // required
  DefaultKeyOnly: true || false,
};
const command = new DescribeKeyRegistrationCommand(input);
const response = await client.send(command);
// { // DescribeKeyRegistrationResponse
//   AwsAccountId: "STRING_VALUE",
//   KeyRegistration: [ // KeyRegistration
//     { // RegisteredCustomerManagedKey
//       KeyArn: "STRING_VALUE",
//       DefaultKey: true || false,
//     },
//   ],
//   QDataKey: { // QDataKey
//     QDataKeyArn: "STRING_VALUE",
//     QDataKeyType: "AWS_OWNED" || "CMK",
//   },
//   RequestId: "STRING_VALUE",
//   Status: Number("int"),
// };

```

--------------------------------

### GetEngineStatusCommand Example

Source: https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/neptunedata/command/GetEngineStatusCommand

Use a bare-bones client and the command you need to make an API call to get the engine status. This example shows the basic setup for importing and using the command.

```javascript
import { NeptunedataClient, GetEngineStatusCommand } from "@aws-sdk/client-neptunedata"; // ES Modules import
// const { NeptunedataClient, GetEngineStatusCommand } = require("@aws-sdk/client-neptunedata"); // CommonJS import
// import type { NeptunedataClientConfig } from "@aws-sdk/client-neptunedata";
const config = {}; // type is NeptunedataClientConfig
const client = new NeptunedataClient(config);
const input = {};
const command = new GetEngineStatusCommand(input);
const response = await client.send(command);
// { // GetEngineStatusOutput
//   status: "STRING_VALUE",
//   startTime: "STRING_VALUE",
//   dbEngineVersion: "STRING_VALUE",
//   role: "STRING_VALUE",
//   dfeQueryEngine: "STRING_VALUE",
//   gremlin: { // QueryLanguageVersion
//     version: "STRING_VALUE", // required
//   },
//   sparql: {
//     version: "STRING_VALUE", // required
//   },
//   opencypher: {
//     version: "STRING_VALUE", // required
//   },
//   labMode: { // StringValuedMap
//     "&lt;keys&gt;": "STRING_VALUE",
//   },
//   rollingBackTrxCount: Number("int"),
//   rollingBackTrxEarliestStartTime: "STRING_VALUE",
//   features: { // DocumentValuedMap
//     "&lt;keys&gt;": "DOCUMENT_VALUE",
//   },
//   settings: {
//     "&lt;keys&gt;": "STRING_VALUE",
//   },
// };

```

--------------------------------

### GetFuotaTaskCommand Example

Source: https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/iot-wireless/command/GetFuotaTaskCommand

Use a bare-bones client and the command you need to make an API call to get FUOTA task information. This example demonstrates the basic setup for making the request.

```javascript
import { IoTWirelessClient, GetFuotaTaskCommand } from "@aws-sdk/client-iot-wireless"; // ES Modules import
// const { IoTWirelessClient, GetFuotaTaskCommand } = require("@aws-sdk/client-iot-wireless"); // CommonJS import
// import type { IoTWirelessClientConfig } from "@aws-sdk/client-iot-wireless";
const config = {}; // type is IoTWirelessClientConfig
const client = new IoTWirelessClient(config);
const input = { // GetFuotaTaskRequest
  Id: "STRING_VALUE", // required
};
const command = new GetFuotaTaskCommand(input);
const response = await client.send(command);
// { // GetFuotaTaskResponse
//   Arn: "STRING_VALUE",
//   Id: "STRING_VALUE",
//   Status: "Pending" || "FuotaSession_Waiting" || "In_FuotaSession" || "FuotaDone" || "Delete_Waiting",
//   Name: "STRING_VALUE",
//   Description: "STRING_VALUE",
//   LoRaWAN: { // LoRaWANFuotaTaskGetInfo
//     RfRegion: "STRING_VALUE",
//     StartTime: new Date("TIMESTAMP"),
//   },
//   FirmwareUpdateImage: "STRING_VALUE",
//   FirmwareUpdateRole: "STRING_VALUE",
//   CreatedAt: new Date("TIMESTAMP"),
//   RedundancyPercent: Number("int"),
//   FragmentSizeBytes: Number("int"),
//   FragmentIntervalMS: Number("int"),
//   Descriptor: "STRING_VALUE",
// };

```

--------------------------------

### Instantiate QBusinessClient and GetApplicationCommand

Source: https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/qbusiness/command/GetApplicationCommand

Shows how to import necessary modules, configure the client, and create a GetApplicationCommand with the required application ID.

```javascript
import { QBusinessClient, GetApplicationCommand } from "@aws-sdk/client-qbusiness"; // ES Modules import
// const { QBusinessClient, GetApplicationCommand } = require("@aws-sdk/client-qbusiness"); // CommonJS import
// import type { QBusinessClientConfig } from "@aws-sdk/client-qbusiness";
const config = {}; // type is QBusinessClientConfig
const client = new QBusinessClient(config);
const input = { // GetApplicationRequest
  applicationId: "STRING_VALUE", // required
};
const command = new GetApplicationCommand(input);
const response = await client.send(command);
```

--------------------------------

### Get Stored Query Example

Source: https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/config-service/command/GetStoredQueryCommand

Use a bare-bones client and the command to make an API call to retrieve a stored query. This example shows the basic setup for using the GetStoredQueryCommand.

```javascript
import {
  ConfigServiceClient,
  GetStoredQueryCommand,
} from "@aws-sdk/client-config-service"; // ES Modules import
// const { ConfigServiceClient, GetStoredQueryCommand } = require("@aws-sdk/client-config-service"); // CommonJS import
// import type { ConfigServiceClientConfig } from "@aws-sdk/client-config-service";
const config = {}; // type is ConfigServiceClientConfig
const client = new ConfigServiceClient(config);
const input = {
  // GetStoredQueryRequest
  QueryName: "STRING_VALUE", // required
};
const command = new GetStoredQueryCommand(input);
const response = await client.send(command);
// { // GetStoredQueryResponse
//   StoredQuery: {
//     QueryId: "STRING_VALUE",
//     QueryArn: "STRING_VALUE",
//     QueryName: "STRING_VALUE", // required
//     Description: "STRING_VALUE",
//     Expression: "STRING_VALUE",
//   },
// };

```

--------------------------------

### StartInstanceOnboardingJobCommand Example

Source: https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/connectcampaignsv2/command/StartInstanceOnboardingJobCommand

Use a bare-bones client and the command you need to make an API call. This example demonstrates how to initialize the ConnectCampaignsV2Client and use the StartInstanceOnboardingJobCommand with necessary input parameters, including instance ID and encryption configuration.

```javascript
import { ConnectCampaignsV2Client, StartInstanceOnboardingJobCommand } from "@aws-sdk/client-connectcampaignsv2"; // ES Modules import
// const { ConnectCampaignsV2Client, StartInstanceOnboardingJobCommand } = require("@aws-sdk/client-connectcampaignsv2"); // CommonJS import
// import type { ConnectCampaignsV2ClientConfig } from "@aws-sdk/client-connectcampaignsv2";
const config = {}; // type is ConnectCampaignsV2ClientConfig
const client = new ConnectCampaignsV2Client(config);
const input = { // StartInstanceOnboardingJobRequest
  connectInstanceId: "STRING_VALUE", // required
  encryptionConfig: { // EncryptionConfig
    enabled: true || false, // required
    encryptionType: "STRING_VALUE",
    keyArn: "STRING_VALUE",
  },
};
const command = new StartInstanceOnboardingJobCommand(input);
const response = await client.send(command);
// { // StartInstanceOnboardingJobResponse
//   connectInstanceOnboardingJobStatus: { // InstanceOnboardingJobStatus
//     connectInstanceId: "STRING_VALUE", // required
//     status: "STRING_VALUE", // required
//     failureCode: "STRING_VALUE",
//   },
// };

```

--------------------------------

### GetApplicationSettingsCommand Example

Source: https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/pinpoint/command/GetApplicationSettingsCommand

Use a bare-bones client and the command you need to make an API call. This example shows how to import the necessary modules, configure the client, define the input for the command, create the command, and send it to the service. It also includes a commented-out structure of the expected response.

```javascript
import { PinpointClient, GetApplicationSettingsCommand } from "@aws-sdk/client-pinpoint"; // ES Modules import
// const { PinpointClient, GetApplicationSettingsCommand } = require("@aws-sdk/client-pinpoint"); // CommonJS import
// import type { PinpointClientConfig } from "@aws-sdk/client-pinpoint";
const config = {}; // type is PinpointClientConfig
const client = new PinpointClient(config);
const input = { // GetApplicationSettingsRequest
  ApplicationId: "STRING_VALUE", // required
};
const command = new GetApplicationSettingsCommand(input);
const response = await client.send(command);
// { // GetApplicationSettingsResponse
//   ApplicationSettingsResource: { // ApplicationSettingsResource
//     ApplicationId: "STRING_VALUE", // required
//     CampaignHook: { // CampaignHook
//       LambdaFunctionName: "STRING_VALUE",
//       Mode: "DELIVERY" || "FILTER",
//       WebUrl: "STRING_VALUE",
//     },
//     LastModifiedDate: "STRING_VALUE",
//     Limits: { // CampaignLimits
//       Daily: Number("int"),
//       MaximumDuration: Number("int"),
//       MessagesPerSecond: Number("int"),
//       Total: Number("int"),
//       Session: Number("int"),
//     },
//     QuietTime: { // QuietTime
//       End: "STRING_VALUE",
//       Start: "STRING_VALUE",
//     },
//     JourneyLimits: { // ApplicationSettingsJourneyLimits
//       DailyCap: Number("int"),
//       TimeframeCap: { // JourneyTimeframeCap
//         Cap: Number("int"),
//         Days: Number("int"),
//       },
//       TotalCap: Number("int"),
//     },
//   },
// };

```

--------------------------------

### Get Endpoint Access

Source: https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/redshift-serverless/command/GetEndpointAccessCommand

Use a bare-bones client and the command to make an API call to get VPC endpoint information. This example demonstrates the basic setup and usage of the GetEndpointAccessCommand.

```javascript
import { RedshiftServerlessClient, GetEndpointAccessCommand } from "@aws-sdk/client-redshift-serverless"; // ES Modules import
// const { RedshiftServerlessClient, GetEndpointAccessCommand } = require("@aws-sdk/client-redshift-serverless"); // CommonJS import
// import type { RedshiftServerlessClientConfig } from "@aws-sdk/client-redshift-serverless";
const config = {}; // type is RedshiftServerlessClientConfig
const client = new RedshiftServerlessClient(config);
const input = { // GetEndpointAccessRequest
  endpointName: "STRING_VALUE", // required
};
const command = new GetEndpointAccessCommand(input);
const response = await client.send(command);
// { // GetEndpointAccessResponse
//   endpoint: { // EndpointAccess
//     endpointName: "STRING_VALUE",
//     endpointStatus: "STRING_VALUE",
//     workgroupName: "STRING_VALUE",
//     endpointCreateTime: new Date("TIMESTAMP"),
//     port: Number("int"),
//     address: "STRING_VALUE",
//     subnetIds: [ // SubnetIdList
//       "STRING_VALUE",
//     ],
//     vpcSecurityGroups: [ // VpcSecurityGroupMembershipList
//       { // VpcSecurityGroupMembership
//         vpcSecurityGroupId: "STRING_VALUE",
//         status: "STRING_VALUE",
//       },
//     ],
//     vpcEndpoint: { // VpcEndpoint
//       vpcEndpointId: "STRING_VALUE",
//       vpcId: "STRING_VALUE",
//       networkInterfaces: [ // NetworkInterfaceList
//         { // NetworkInterface
//           networkInterfaceId: "STRING_VALUE",
//           subnetId: "STRING_VALUE",
//           privateIpAddress: "STRING_VALUE",
//           availabilityZone: "STRING_VALUE",
//           ipv6Address: "STRING_VALUE",
//         },
//       ],
//     },
//     endpointArn: "STRING_VALUE",
//   },
// };

```

--------------------------------

### StartServerCommand Example

Source: https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/transfer/command/StartServerCommand

Use a bare-bones client and the command you need to make an API call. This example shows how to import the necessary modules, configure the client, and send the StartServerCommand with the required ServerId.

```javascript
import {
  TransferClient,
  StartServerCommand
} from "@aws-sdk/client-transfer"; // ES Modules import

// const { TransferClient, StartServerCommand } = require("@aws-sdk/client-transfer"); // CommonJS import
// import type { TransferClientConfig } from "@aws-sdk/client-transfer";

const config = {}; // type is TransferClientConfig
const client = new TransferClient(config);
const input = {
  // StartServerRequest
  ServerId: "STRING_VALUE", // required
};

const command = new StartServerCommand(input);
const response = await client.send(command);
// {};
```

--------------------------------

### Get Setup History for a Lightsail Resource

Source: https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/lightsail/command/GetSetupHistoryCommand

Use a bare-bones client and the command you need to make an API call to get the setup history of a specific Lightsail resource. This example shows how to import the necessary modules, configure the client, and send the command with input parameters.

```javascript
import { LightsailClient, GetSetupHistoryCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
// const { LightsailClient, GetSetupHistoryCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
// import type { LightsailClientConfig } from "@aws-sdk/client-lightsail";
const config = {}; // type is LightsailClientConfig
const client = new LightsailClient(config);
const input = {
  resourceName: "STRING_VALUE", // required
  pageToken: "STRING_VALUE",
};
const command = new GetSetupHistoryCommand(input);
const response = await client.send(command);
```

--------------------------------

### GetOutpostCommand Example

Source: https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/outposts/command/GetOutpostCommand

Use a bare-bones client and the command you need to make an API call to get Outpost information. This example demonstrates ES Modules import. Ensure you have the '@aws-sdk/client-outposts' package installed.

```javascript
import { OutpostsClient, GetOutpostCommand } from "@aws-sdk/client-outposts"; // ES Modules import
// const { OutpostsClient, GetOutpostCommand } = require("@aws-sdk/client-outposts"); // CommonJS import
// import type { OutpostsClientConfig } from "@aws-sdk/client-outposts";
const config = {}; // type is OutpostsClientConfig
const client = new OutpostsClient(config);
const input = { // GetOutpostInput
  OutpostId: "STRING_VALUE", // required
};
const command = new GetOutpostCommand(input);
const response = await client.send(command);
// { // GetOutpostOutput
//   Outpost: { // Outpost
//     OutpostId: "STRING_VALUE",
//     OwnerId: "STRING_VALUE",
//     OutpostArn: "STRING_VALUE",
//     SiteId: "STRING_VALUE",
//     Name: "STRING_VALUE",
//     Description: "STRING_VALUE",
//     LifeCycleStatus: "STRING_VALUE",
//     AvailabilityZone: "STRING_VALUE",
//     AvailabilityZoneId: "STRING_VALUE",
//     Tags: { // TagMap
//       "&lt;keys&gt;": "STRING_VALUE",
//     },
//     SiteArn: "STRING_VALUE",
//     SupportedHardwareType: "RACK" || "SERVER",
//   },
// };

```

--------------------------------

### Initialize QBusinessClient and use GetPluginCommand

Source: https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/qbusiness/command/GetPluginCommand

This snippet shows the basic setup for making an API call to get plugin details. It includes importing necessary modules, initializing the client with configuration, defining the input for the command, creating the command instance, and sending it to the service.

```javascript
import { QBusinessClient, GetPluginCommand } from "@aws-sdk/client-qbusiness"; // ES Modules import
// const { QBusinessClient, GetPluginCommand } = require("@aws-sdk/client-qbusiness"); // CommonJS import
// import type { QBusinessClientConfig } from "@aws-sdk/client-qbusiness";
const config = {}; // type is QBusinessClientConfig
const client = new QBusinessClient(config);
const input = { // GetPluginRequest
  applicationId: "STRING_VALUE", // required
  pluginId: "STRING_VALUE", // required
};
const command = new GetPluginCommand(input);
const response = await client.send(command);
```

--------------------------------

### DescribeQuickSightQSearchConfigurationCommand Example

Source: https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/quicksight/command/DescribeQuickSightQSearchConfigurationCommand

Use a bare-bones client and the command you need to make an API call. This example shows how to instantiate the client, create the command with required input, and send the command to retrieve the Q Search configuration status.

```javascript
import { QuickSightClient, DescribeQuickSightQSearchConfigurationCommand } from "@aws-sdk/client-quicksight"; // ES Modules import
// const { QuickSightClient, DescribeQuickSightQSearchConfigurationCommand } = require("@aws-sdk/client-quicksight"); // CommonJS import
// import type { QuickSightClientConfig } from "@aws-sdk/client-quicksight";
const config = {}; // type is QuickSightClientConfig
const client = new QuickSightClient(config);
const input = { // DescribeQuickSightQSearchConfigurationRequest
  AwsAccountId: "STRING_VALUE", // required
};
const command = new DescribeQuickSightQSearchConfigurationCommand(input);
const response = await client.send(command);
// { // DescribeQuickSightQSearchConfigurationResponse
//   QSearchStatus: "ENABLED" || "DISABLED",
//   RequestId: "STRING_VALUE",
//   Status: Number("int"),
// };

```

--------------------------------

### GetDataProtectionPolicyCommand Example

Source: https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/cloudwatch-logs/command/GetDataProtectionPolicyCommand

Use a bare-bones client and the command you need to make an API call to get data protection policy information for a log group. This example shows the basic setup for using the command.

```javascript
import { CloudWatchLogsClient, GetDataProtectionPolicyCommand } from "@aws-sdk/client-cloudwatch-logs"; // ES Modules import
// const { CloudWatchLogsClient, GetDataProtectionPolicyCommand } = require("@aws-sdk/client-cloudwatch-logs"); // CommonJS import
// import type { CloudWatchLogsClientConfig } from "@aws-sdk/client-cloudwatch-logs";
const config = {}; // type is CloudWatchLogsClientConfig
const client = new CloudWatchLogsClient(config);
const input = { // GetDataProtectionPolicyRequest
  logGroupIdentifier: "STRING_VALUE", // required
};
const command = new GetDataProtectionPolicyCommand(input);
const response = await client.send(command);
// { // GetDataProtectionPolicyResponse
//   logGroupIdentifier: "STRING_VALUE",
//   policyDocument: "STRING_VALUE",
//   lastUpdatedTime: Number("long"),
// };

```

--------------------------------

### Get Multi-Region Access Point Policy

Source: https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/s3-control/command/GetMultiRegionAccessPointPolicyCommand

Use a bare-bones client and the command you need to make an API call to get the policy of a Multi-Region Access Point. This example demonstrates the basic setup and usage.

```javascript
import { S3ControlClient, GetMultiRegionAccessPointPolicyCommand } from "@aws-sdk/client-s3-control"; // ES Modules import
// const { S3ControlClient, GetMultiRegionAccessPointPolicyCommand } = require("@aws-sdk/client-s3-control"); // CommonJS import
// import type { S3ControlClientConfig } from "@aws-sdk/client-s3-control";
const config = {}; // type is S3ControlClientConfig
const client = new S3ControlClient(config);
const input = { // GetMultiRegionAccessPointPolicyRequest
  AccountId: "STRING_VALUE",
  Name: "STRING_VALUE", // required
};
const command = new GetMultiRegionAccessPointPolicyCommand(input);
const response = await client.send(command);
// { // GetMultiRegionAccessPointPolicyResult
//   Policy: { // MultiRegionAccessPointPolicyDocument
//     Established: { // EstablishedMultiRegionAccessPointPolicy
//       Policy: "STRING_VALUE",
//     },
//     Proposed: { // ProposedMultiRegionAccessPointPolicy
//       Policy: "STRING_VALUE",
//     },
//   },
// };

```

--------------------------------

### ListAppVersionsCommand Example

Source: https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/resiliencehub/command/ListAppVersionsCommand

Use a bare-bones client and the command you need to make an API call. This example demonstrates how to instantiate the client, define input parameters, create the command, and send it to the service. It also shows the expected response structure.

```javascript
import { ResiliencehubClient, ListAppVersionsCommand } from "@aws-sdk/client-resiliencehub"; // ES Modules import
// const { ResiliencehubClient, ListAppVersionsCommand } = require("@aws-sdk/client-resiliencehub"); // CommonJS import
// import type { ResiliencehubClientConfig } from "@aws-sdk/client-resiliencehub";
const config = {}; // type is ResiliencehubClientConfig
const client = new ResiliencehubClient(config);
const input = { // ListAppVersionsRequest
  appArn: "STRING_VALUE", // required
  nextToken: "STRING_VALUE",
  maxResults: Number("int"),
  startTime: new Date("TIMESTAMP"),
  endTime: new Date("TIMESTAMP"),
};
const command = new ListAppVersionsCommand(input);
const response = await client.send(command);
// { // ListAppVersionsResponse
//   appVersions: [ // AppVersionList // required
//     { // AppVersionSummary
//       appVersion: "STRING_VALUE", // required
//       identifier: Number("long"),
//       creationTime: new Date("TIMESTAMP"),
//       versionName: "STRING_VALUE",
//     },
//   ],
//   nextToken: "STRING_VALUE",
// };

```

--------------------------------

### Get Traffic Policy Instance

Source: https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/route-53/command/GetTrafficPolicyInstanceCommand

Use a bare-bones client and the command you need to make an API call to get traffic policy instance details. This example demonstrates the basic setup and usage of the GetTrafficPolicyInstanceCommand.

```javascript
import { Route53Client, GetTrafficPolicyInstanceCommand } from "@aws-sdk/client-route-53"; // ES Modules import
// const { Route53Client, GetTrafficPolicyInstanceCommand } = require("@aws-sdk/client-route-53"); // CommonJS import
// import type { Route53ClientConfig } from "@aws-sdk/client-route-53";
const config = {}; // type is Route53ClientConfig
const client = new Route53Client(config);
const input = { // GetTrafficPolicyInstanceRequest
  Id: "STRING_VALUE", // required
};
const command = new GetTrafficPolicyInstanceCommand(input);
const response = await client.send(command);
// { // GetTrafficPolicyInstanceResponse
//   TrafficPolicyInstance: { // TrafficPolicyInstance
//     Id: "STRING_VALUE", // required
//     HostedZoneId: "STRING_VALUE", // required
//     Name: "STRING_VALUE", // required
//     TTL: Number("long"), // required
//     State: "STRING_VALUE", // required
//     Message: "STRING_VALUE", // required
//     TrafficPolicyId: "STRING_VALUE", // required
//     TrafficPolicyVersion: Number("int"), // required
//     TrafficPolicyType: "SOA" || "A" || "TXT" || "NS" || "CNAME" || "MX" || "NAPTR" || "PTR" || "SRV" || "SPF" || "AAAA" || "CAA" || "DS" || "TLSA" || "SSHFP" || "SVCB" || "HTTPS", // required
//   },
// };

```

--------------------------------

### DescribeSelfUpgradeConfigurationCommand Example

Source: https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/quicksight/command/DescribeSelfUpgradeConfigurationCommand

Use a bare-bones client and the command you need to make an API call. This example demonstrates how to instantiate the QuickSightClient and use the DescribeSelfUpgradeConfigurationCommand to retrieve self-upgrade configuration details.

```javascript
import { QuickSightClient, DescribeSelfUpgradeConfigurationCommand } from "@aws-sdk/client-quicksight"; // ES Modules import
// const { QuickSightClient, DescribeSelfUpgradeConfigurationCommand } = require("@aws-sdk/client-quicksight"); // CommonJS import
// import type { QuickSightClientConfig } from "@aws-sdk/client-quicksight";
const config = {}; // type is QuickSightClientConfig
const client = new QuickSightClient(config);
const input = { // DescribeSelfUpgradeConfigurationRequest
  AwsAccountId: "STRING_VALUE", // required
  Namespace: "STRING_VALUE", // required
};
const command = new DescribeSelfUpgradeConfigurationCommand(input);
const response = await client.send(command);
// { // DescribeSelfUpgradeConfigurationResponse
//   SelfUpgradeConfiguration: { // SelfUpgradeConfiguration
//     SelfUpgradeStatus: "AUTO_APPROVAL" || "ADMIN_APPROVAL",
//   },
//   RequestId: "STRING_VALUE",
//   Status: Number("int"),
// };

```

--------------------------------

### Get Wireless Gateway Statistics

Source: https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/iot-wireless/command/GetWirelessGatewayStatisticsCommand

Use a bare-bones client and the command you need to make an API call to get wireless gateway statistics. This example shows the basic setup for using the IoTWirelessClient and GetWirelessGatewayStatisticsCommand.

```javascript
import {
  IoTWirelessClient,
  GetWirelessGatewayStatisticsCommand,
} from "@aws-sdk/client-iot-wireless"; // ES Modules import

// const { IoTWirelessClient, GetWirelessGatewayStatisticsCommand } = require("@aws-sdk/client-iot-wireless"); // CommonJS import
// import type { IoTWirelessClientConfig } from "@aws-sdk/client-iot-wireless";

const config = {}; // type is IoTWirelessClientConfig
const client = new IoTWirelessClient(config);
const input = {
  // GetWirelessGatewayStatisticsRequest
  WirelessGatewayId: "STRING_VALUE", // required
};

const command = new GetWirelessGatewayStatisticsCommand(input);
const response = await client.send(command);

// { // GetWirelessGatewayStatisticsResponse
//   WirelessGatewayId: "STRING_VALUE",
//   LastUplinkReceivedAt: "STRING_VALUE",
//   ConnectionStatus: "Connected" || "Disconnected",
// };

```

--------------------------------

### ListVPCEConfigurationsCommand Example

Source: https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/device-farm/command/ListVPCEConfigurationsCommand

Use a bare-bones client and the command you need to make an API call. This example shows how to import the necessary components, configure the client, create the command with input parameters, and send the command to the Device Farm service.

```javascript
import { DeviceFarmClient, ListVPCEConfigurationsCommand } from "@aws-sdk/client-device-farm"; // ES Modules import
// const { DeviceFarmClient, ListVPCEConfigurationsCommand } = require("@aws-sdk/client-device-farm"); // CommonJS import
// import type { DeviceFarmClientConfig } from "@aws-sdk/client-device-farm";
const config = {}; // type is DeviceFarmClientConfig
const client = new DeviceFarmClient(config);
const input = { // ListVPCEConfigurationsRequest
  maxResults: Number("int"),
  nextToken: "STRING_VALUE",
};
const command = new ListVPCEConfigurationsCommand(input);
const response = await client.send(command);
// { // ListVPCEConfigurationsResult
//   vpceConfigurations: [ // VPCEConfigurations
//     { // VPCEConfiguration
//       arn: "STRING_VALUE",
//       vpceConfigurationName: "STRING_VALUE",
//       vpceServiceName: "STRING_VALUE",
//       serviceDnsName: "STRING_VALUE",
//       vpceConfigurationDescription: "STRING_VALUE",
//     },
//   ],
//   nextToken: "STRING_VALUE",
// };

```

--------------------------------

### Get ML Input Channel

Source: https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/cleanroomsml/command/GetMLInputChannelCommand

Use a bare-bones client and the command you need to make an API call to get ML input channel details. This example demonstrates the basic setup and usage of the GetMLInputChannelCommand.

```javascript
import { CleanRoomsMLClient, GetMLInputChannelCommand } from "@aws-sdk/client-cleanroomsml"; // ES Modules import
// const { CleanRoomsMLClient, GetMLInputChannelCommand } = require("@aws-sdk/client-cleanroomsml"); // CommonJS import
// import type { CleanRoomsMLClientConfig } from "@aws-sdk/client-cleanroomsml";
const config = {}; // type is CleanRoomsMLClientConfig
const client = new CleanRoomsMLClient(config);
const input = { // GetMLInputChannelRequest
  mlInputChannelArn: "STRING_VALUE", // required
  membershipIdentifier: "STRING_VALUE", // required
};
const command = new GetMLInputChannelCommand(input);
const response = await client.send(command);
```

--------------------------------

### Initialize Client and Send GetQAppCommand

Source: https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/qapps/command/GetQAppCommand

This snippet shows the basic setup for making an API call to get a QApp. It includes importing necessary modules, configuring the client, defining input parameters, creating the command, and sending it.

```javascript
import { QAppsClient, GetQAppCommand } from "@aws-sdk/client-qapps"; // ES Modules import
// const { QAppsClient, GetQAppCommand } = require("@aws-sdk/client-qapps"); // CommonJS import
// import type { QAppsClientConfig } from "@aws-sdk/client-qapps";
const config = {}; // type is QAppsClientConfig
const client = new QAppsClient(config);
const input = { // GetQAppInput
  instanceId: "STRING_VALUE", // required
  appId: "STRING_VALUE", // required
  appVersion: Number("int"),
};
const command = new GetQAppCommand(input);
const response = await client.send(command);
```

--------------------------------

### Get Managed Thing Capabilities

Source: https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/iot-managed-integrations/command/GetManagedThingCapabilitiesCommand

Use a bare-bones client and the command you need to make an API call to get managed thing capabilities. This example shows the basic setup for initializing the client and sending the command.

```javascript
import { IoTManagedIntegrationsClient, GetManagedThingCapabilitiesCommand } from "@aws-sdk/client-iot-managed-integrations"; // ES Modules import
// const { IoTManagedIntegrationsClient, GetManagedThingCapabilitiesCommand } = require("@aws-sdk/client-iot-managed-integrations"); // CommonJS import
// import type { IoTManagedIntegrationsClientConfig } from "@aws-sdk/client-iot-managed-integrations";
const config = {}; // type is IoTManagedIntegrationsClientConfig
const client = new IoTManagedIntegrationsClient(config);
const input = { // GetManagedThingCapabilitiesRequest
  Identifier: "STRING_VALUE", // required
};
const command = new GetManagedThingCapabilitiesCommand(input);
const response = await client.send(command);
// { // GetManagedThingCapabilitiesResponse
//   ManagedThingId: "STRING_VALUE",
//   Capabilities: "STRING_VALUE",
//   CapabilityReport: { // CapabilityReport
//     version: "STRING_VALUE", // required
//     nodeId: "STRING_VALUE",
//     endpoints: [ // CapabilityReportEndpoints // required
//       { // CapabilityReportEndpoint
//         id: "STRING_VALUE", // required
//         deviceTypes: [ // DeviceTypes // required
//           "STRING_VALUE",
//         ],
//         capabilities: [ // CapabilityReportCapabilities // required
//           { // CapabilityReportCapability
//             id: "STRING_VALUE", // required
//             name: "STRING_VALUE", // required
//             version: "STRING_VALUE", // required
//             properties: [ // CapabilityReportProperties // required
//               "STRING_VALUE",
//             ],
//             actions: [ // CapabilityReportActions // required
//               "STRING_VALUE",
//             ],
//             events: [ // CapabilityReportEvents // required
//               "STRING_VALUE",
//             ],
//           },
//         ],
//       },
//     ],
//   },
// };

```

--------------------------------

### ListAdConfigurationsCommand Example

Source: https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/ivs/command/ListAdConfigurationsCommand

Use a bare-bones client and the command you need to make an API call. This example shows how to import the necessary modules, configure the client, define input parameters, create the command, and send it to the client. It also includes the expected response structure.

```javascript
import { IvsClient, ListAdConfigurationsCommand } from "@aws-sdk/client-ivs"; // ES Modules import
// const { IvsClient, ListAdConfigurationsCommand } = require("@aws-sdk/client-ivs"); // CommonJS import
// import type { IvsClientConfig } from "@aws-sdk/client-ivs";
const config = {}; // type is IvsClientConfig
const client = new IvsClient(config);
const input = { // ListAdConfigurationsRequest
  nextToken: "STRING_VALUE",
  maxResults: Number("int"),
};
const command = new ListAdConfigurationsCommand(input);
const response = await client.send(command);
// { // ListAdConfigurationsResponse
//   adConfigurations: [ // AdConfigurationList // required
//     { // AdConfigurationSummary
//       arn: "STRING_VALUE", // required
//       name: "STRING_VALUE",
//       mediaTailorPlaybackConfigurations: [ // MediaTailorPlaybackConfigurationsList // required
//         { // MediaTailorPlaybackConfiguration
//           playbackConfigurationArn: "STRING_VALUE",
//         },
//       ],
//       tags: { // Tags
//         "&lt;keys&gt;": "STRING_VALUE",
//       },
//     },
//   ],
//   nextToken: "STRING_VALUE",
// };

```

--------------------------------

### ListComponentBuildVersionsCommand Example

Source: https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/imagebuilder/command/ListComponentBuildVersionsCommand

Use a bare-bones client and the command you need to make an API call. This example shows how to import the necessary modules, configure the client, define the input parameters for the command, create the command, and send it to the client. It also includes the expected response structure.

```javascript
import { ImagebuilderClient, ListComponentBuildVersionsCommand } from "@aws-sdk/client-imagebuilder"; // ES Modules import
// const { ImagebuilderClient, ListComponentBuildVersionsCommand } = require("@aws-sdk/client-imagebuilder"); // CommonJS import
// import type { ImagebuilderClientConfig } from "@aws-sdk/client-imagebuilder";
const config = {}; // type is ImagebuilderClientConfig
const client = new ImagebuilderClient(config);
const input = { // ListComponentBuildVersionsRequest
  componentVersionArn: "STRING_VALUE",
  maxResults: Number("int"),
  nextToken: "STRING_VALUE",
};
const command = new ListComponentBuildVersionsCommand(input);
const response = await client.send(command);
// { // ListComponentBuildVersionsResponse
//   requestId: "STRING_VALUE",
//   componentSummaryList: [ // ComponentSummaryList
//     { // ComponentSummary
//       arn: "STRING_VALUE",
//       name: "STRING_VALUE",
//       version: "STRING_VALUE",
//       platform: "Windows" || "Linux" || "macOS",
//       supportedOsVersions: [ // OsVersionList
//         "STRING_VALUE",
//       ],
//       state: { // ComponentState
//         status: "DEPRECATED" || "DISABLED" || "ACTIVE",
//         reason: "STRING_VALUE",
//       },
//       type: "BUILD" || "TEST",
//       owner: "STRING_VALUE",
//       description: "STRING_VALUE",
//       changeDescription: "STRING_VALUE",
//       dateCreated: "STRING_VALUE",
//       tags: { // TagMap
//         "&lt;keys&gt;": "STRING_VALUE",
//       },
//       publisher: "STRING_VALUE",
//       obfuscate: true || false,
//     },
//   ],
//   nextToken: "STRING_VALUE",
// };

```