@aws-sdk/client-greengrassv2 3.315.0 → 3.319.0

package/dist-types/GreengrassV2.d.ts

@@ -29,454 +29,195 @@ import { TagResourceCommandInput, TagResourceCommandOutput } from "./commands/Ta
 import { UntagResourceCommandInput, UntagResourceCommandOutput } from "./commands/UntagResourceCommand";
 import { UpdateConnectivityInfoCommandInput, UpdateConnectivityInfoCommandOutput } from "./commands/UpdateConnectivityInfoCommand";
 import { GreengrassV2Client } from "./GreengrassV2Client";
-/**
- * @public
- * <p>IoT Greengrass brings local compute, messaging, data management, sync, and ML inference capabilities
- *       to edge devices. This enables devices to collect and analyze data closer to the source of
- *       information, react autonomously to local events, and communicate securely with each other on
- *       local networks. Local devices can also communicate securely with Amazon Web Services IoT Core and export IoT data
- *       to the Amazon Web Services Cloud. IoT Greengrass developers can use Lambda functions and components to create and
- *       deploy applications to fleets of edge devices for local operation.</p>
- *          <p>IoT Greengrass Version 2 provides a new major version of the IoT Greengrass Core software, new APIs, and a new console.
- *       Use this API reference to learn how to use the IoT Greengrass V2 API operations to manage components,
- *       manage deployments, and core devices.</p>
- *          <p>For more information, see <a href="https://docs.aws.amazon.com/greengrass/v2/developerguide/what-is-iot-greengrass.html">What is IoT Greengrass?</a> in the
- *         <i>IoT Greengrass V2 Developer Guide</i>.</p>
- */
-export declare class GreengrassV2 extends GreengrassV2Client {
+export interface GreengrassV2 {
     /**
-     * @public
-     * <p>Associates a Greengrass service role with IoT Greengrass for your Amazon Web Services account in this Amazon Web Services Region. IoT Greengrass
-     *       uses this role to verify the identity of client devices and manage core device connectivity
-     *       information. The role must include the <a href="https://console.aws.amazon.com/iam/home#/policies/arn:awsiam::aws:policy/service-role/AWSGreengrassResourceAccessRolePolicy">AWSGreengrassResourceAccessRolePolicy</a> managed policy or a custom policy that
-     *       defines equivalent permissions for the IoT Greengrass features that you use. For more information, see
-     *         <a href="https://docs.aws.amazon.com/greengrass/v2/developerguide/greengrass-service-role.html">Greengrass service role</a> in the <i>IoT Greengrass Version 2 Developer Guide</i>.</p>
+     * @see {@link AssociateServiceRoleToAccountCommand}
      */
     associateServiceRoleToAccount(args: AssociateServiceRoleToAccountCommandInput, options?: __HttpHandlerOptions): Promise<AssociateServiceRoleToAccountCommandOutput>;
     associateServiceRoleToAccount(args: AssociateServiceRoleToAccountCommandInput, cb: (err: any, data?: AssociateServiceRoleToAccountCommandOutput) => void): void;
     associateServiceRoleToAccount(args: AssociateServiceRoleToAccountCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: AssociateServiceRoleToAccountCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Associates a list of client devices with a core device. Use this API operation to specify
-     *       which client devices can discover a core device through cloud discovery. With cloud discovery,
-     *       client devices connect to IoT Greengrass to retrieve associated core devices' connectivity information
-     *       and certificates. For more information, see <a href="https://docs.aws.amazon.com/greengrass/v2/developerguide/configure-cloud-discovery.html">Configure cloud
-     *         discovery</a> in the <i>IoT Greengrass V2 Developer Guide</i>.</p>
-     *          <note>
-     *             <p>Client devices are local IoT devices that connect to and communicate with an IoT Greengrass core
-     *         device over MQTT. You can connect client devices to a core device to sync MQTT messages and
-     *         data to Amazon Web Services IoT Core and interact with client devices in Greengrass components. For more information,
-     *         see <a href="https://docs.aws.amazon.com/greengrass/v2/developerguide/interact-with-local-iot-devices.html">Interact with
-     *           local IoT devices</a> in the <i>IoT Greengrass V2 Developer Guide</i>.</p>
-     *          </note>
+     * @see {@link BatchAssociateClientDeviceWithCoreDeviceCommand}
      */
     batchAssociateClientDeviceWithCoreDevice(args: BatchAssociateClientDeviceWithCoreDeviceCommandInput, options?: __HttpHandlerOptions): Promise<BatchAssociateClientDeviceWithCoreDeviceCommandOutput>;
     batchAssociateClientDeviceWithCoreDevice(args: BatchAssociateClientDeviceWithCoreDeviceCommandInput, cb: (err: any, data?: BatchAssociateClientDeviceWithCoreDeviceCommandOutput) => void): void;
     batchAssociateClientDeviceWithCoreDevice(args: BatchAssociateClientDeviceWithCoreDeviceCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: BatchAssociateClientDeviceWithCoreDeviceCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Disassociates a list of client devices from a core device. After you disassociate a client
-     *       device from a core device, the client device won't be able to use cloud discovery to retrieve
-     *       the core device's connectivity information and certificates.</p>
+     * @see {@link BatchDisassociateClientDeviceFromCoreDeviceCommand}
      */
     batchDisassociateClientDeviceFromCoreDevice(args: BatchDisassociateClientDeviceFromCoreDeviceCommandInput, options?: __HttpHandlerOptions): Promise<BatchDisassociateClientDeviceFromCoreDeviceCommandOutput>;
     batchDisassociateClientDeviceFromCoreDevice(args: BatchDisassociateClientDeviceFromCoreDeviceCommandInput, cb: (err: any, data?: BatchDisassociateClientDeviceFromCoreDeviceCommandOutput) => void): void;
     batchDisassociateClientDeviceFromCoreDevice(args: BatchDisassociateClientDeviceFromCoreDeviceCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: BatchDisassociateClientDeviceFromCoreDeviceCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Cancels a deployment. This operation cancels the deployment for devices that haven't yet
-     *       received it. If a device already received the deployment, this operation doesn't change
-     *       anything for that device.</p>
+     * @see {@link CancelDeploymentCommand}
      */
     cancelDeployment(args: CancelDeploymentCommandInput, options?: __HttpHandlerOptions): Promise<CancelDeploymentCommandOutput>;
     cancelDeployment(args: CancelDeploymentCommandInput, cb: (err: any, data?: CancelDeploymentCommandOutput) => void): void;
     cancelDeployment(args: CancelDeploymentCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: CancelDeploymentCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Creates a component. Components are software that run on Greengrass core devices. After you
-     *       develop and test a component on your core device, you can use this operation to upload your
-     *       component to IoT Greengrass. Then, you can deploy the component to other core devices.</p>
-     *          <p>You can use this operation to do the following:</p>
-     *          <ul>
-     *             <li>
-     *                <p>
-     *                   <b>Create components from recipes</b>
-     *                </p>
-     *                <p>Create a component from a recipe, which is a file that defines the component's
-     *           metadata, parameters, dependencies, lifecycle, artifacts, and platform capability. For
-     *           more information, see <a href="https://docs.aws.amazon.com/greengrass/v2/developerguide/component-recipe-reference.html">IoT Greengrass component recipe
-     *             reference</a> in the <i>IoT Greengrass V2 Developer Guide</i>.</p>
-     *                <p>To create a component from a recipe, specify <code>inlineRecipe</code> when you call
-     *           this operation.</p>
-     *             </li>
-     *             <li>
-     *                <p>
-     *                   <b>Create components from Lambda functions</b>
-     *                </p>
-     *                <p>Create a component from an Lambda function that runs on IoT Greengrass. This creates a recipe
-     *           and artifacts from the Lambda function's deployment package. You can use this operation to
-     *           migrate Lambda functions from IoT Greengrass V1 to IoT Greengrass V2.</p>
-     *                <p>This function only accepts Lambda functions that use the following runtimes:</p>
-     *                <ul>
-     *                   <li>
-     *                      <p>Python 2.7 – <code>python2.7</code>
-     *                      </p>
-     *                   </li>
-     *                   <li>
-     *                      <p>Python 3.7 – <code>python3.7</code>
-     *                      </p>
-     *                   </li>
-     *                   <li>
-     *                      <p>Python 3.8 – <code>python3.8</code>
-     *                      </p>
-     *                   </li>
-     *                   <li>
-     *                      <p>Python 3.9 – <code>python3.9</code>
-     *                      </p>
-     *                   </li>
-     *                   <li>
-     *                      <p>Java 8 – <code>java8</code>
-     *                      </p>
-     *                   </li>
-     *                   <li>
-     *                      <p>Java 11 – <code>java11</code>
-     *                      </p>
-     *                   </li>
-     *                   <li>
-     *                      <p>Node.js 10 – <code>nodejs10.x</code>
-     *                      </p>
-     *                   </li>
-     *                   <li>
-     *                      <p>Node.js 12 – <code>nodejs12.x</code>
-     *                      </p>
-     *                   </li>
-     *                   <li>
-     *                      <p>Node.js 14 – <code>nodejs14.x</code>
-     *                      </p>
-     *                   </li>
-     *                </ul>
-     *                <p>To create a component from a Lambda function, specify <code>lambdaFunction</code> when
-     *           you call this operation.</p>
-     *                <note>
-     *                   <p>IoT Greengrass currently supports Lambda functions on only Linux core devices.</p>
-     *                </note>
-     *             </li>
-     *          </ul>
+     * @see {@link CreateComponentVersionCommand}
      */
     createComponentVersion(args: CreateComponentVersionCommandInput, options?: __HttpHandlerOptions): Promise<CreateComponentVersionCommandOutput>;
     createComponentVersion(args: CreateComponentVersionCommandInput, cb: (err: any, data?: CreateComponentVersionCommandOutput) => void): void;
     createComponentVersion(args: CreateComponentVersionCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: CreateComponentVersionCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Creates a continuous deployment for a target, which is a Greengrass core device or group of core
-     *       devices. When you add a new core device to a group of core devices that has a deployment, IoT Greengrass
-     *       deploys that group's deployment to the new device.</p>
-     *          <p>You can define one deployment for each target. When you create a new deployment for a
-     *       target that has an existing deployment, you replace the previous deployment. IoT Greengrass applies the
-     *       new deployment to the target devices.</p>
-     *          <p>Every deployment has a revision number that indicates how many deployment revisions you
-     *       define for a target. Use this operation to create a new revision of an existing
-     *       deployment.</p>
-     *          <p>For more information, see the <a href="https://docs.aws.amazon.com/greengrass/v2/developerguide/create-deployments.html">Create deployments</a> in the
-     *         <i>IoT Greengrass V2 Developer Guide</i>.</p>
+     * @see {@link CreateDeploymentCommand}
      */
     createDeployment(args: CreateDeploymentCommandInput, options?: __HttpHandlerOptions): Promise<CreateDeploymentCommandOutput>;
     createDeployment(args: CreateDeploymentCommandInput, cb: (err: any, data?: CreateDeploymentCommandOutput) => void): void;
     createDeployment(args: CreateDeploymentCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: CreateDeploymentCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Deletes a version of a component from IoT Greengrass.</p>
-     *          <note>
-     *             <p>This operation deletes the component's recipe and artifacts. As a result, deployments
-     *         that refer to this component version will fail. If you have deployments that use this
-     *         component version, you can remove the component from the deployment or update the deployment
-     *         to use a valid version.</p>
-     *          </note>
+     * @see {@link DeleteComponentCommand}
      */
     deleteComponent(args: DeleteComponentCommandInput, options?: __HttpHandlerOptions): Promise<DeleteComponentCommandOutput>;
     deleteComponent(args: DeleteComponentCommandInput, cb: (err: any, data?: DeleteComponentCommandOutput) => void): void;
     deleteComponent(args: DeleteComponentCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DeleteComponentCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Deletes a Greengrass core device, which is an IoT thing. This operation removes the core
-     *       device from the list of core devices. This operation doesn't delete the IoT thing. For more
-     *       information about how to delete the IoT thing, see <a href="https://docs.aws.amazon.com/iot/latest/apireference/API_DeleteThing.html">DeleteThing</a> in the
-     *         <i>IoT API Reference</i>.</p>
+     * @see {@link DeleteCoreDeviceCommand}
      */
     deleteCoreDevice(args: DeleteCoreDeviceCommandInput, options?: __HttpHandlerOptions): Promise<DeleteCoreDeviceCommandOutput>;
     deleteCoreDevice(args: DeleteCoreDeviceCommandInput, cb: (err: any, data?: DeleteCoreDeviceCommandOutput) => void): void;
     deleteCoreDevice(args: DeleteCoreDeviceCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DeleteCoreDeviceCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Deletes a deployment. To delete an active deployment, you must first cancel it. For more
-     *       information, see <a href="https://docs.aws.amazon.com/iot/latest/apireference/API_CancelDeployment.html">CancelDeployment</a>.</p>
-     *          <p>Deleting a deployment doesn't affect core devices that run that deployment, because core
-     *       devices store the deployment's configuration on the device. Additionally, core devices can
-     *       roll back to a previous deployment that has been deleted.</p>
+     * @see {@link DeleteDeploymentCommand}
      */
     deleteDeployment(args: DeleteDeploymentCommandInput, options?: __HttpHandlerOptions): Promise<DeleteDeploymentCommandOutput>;
     deleteDeployment(args: DeleteDeploymentCommandInput, cb: (err: any, data?: DeleteDeploymentCommandOutput) => void): void;
     deleteDeployment(args: DeleteDeploymentCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DeleteDeploymentCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Retrieves metadata for a version of a component.</p>
+     * @see {@link DescribeComponentCommand}
      */
     describeComponent(args: DescribeComponentCommandInput, options?: __HttpHandlerOptions): Promise<DescribeComponentCommandOutput>;
     describeComponent(args: DescribeComponentCommandInput, cb: (err: any, data?: DescribeComponentCommandOutput) => void): void;
     describeComponent(args: DescribeComponentCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DescribeComponentCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Disassociates the Greengrass service role from IoT Greengrass for your Amazon Web Services account in this Amazon Web Services Region.
-     *       Without a service role, IoT Greengrass can't verify the identity of client devices or manage core device
-     *       connectivity information. For more information, see <a href="https://docs.aws.amazon.com/greengrass/v2/developerguide/greengrass-service-role.html">Greengrass service role</a> in
-     *       the <i>IoT Greengrass Version 2 Developer Guide</i>.</p>
+     * @see {@link DisassociateServiceRoleFromAccountCommand}
      */
     disassociateServiceRoleFromAccount(args: DisassociateServiceRoleFromAccountCommandInput, options?: __HttpHandlerOptions): Promise<DisassociateServiceRoleFromAccountCommandOutput>;
     disassociateServiceRoleFromAccount(args: DisassociateServiceRoleFromAccountCommandInput, cb: (err: any, data?: DisassociateServiceRoleFromAccountCommandOutput) => void): void;
     disassociateServiceRoleFromAccount(args: DisassociateServiceRoleFromAccountCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DisassociateServiceRoleFromAccountCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Gets the recipe for a version of a component.</p>
+     * @see {@link GetComponentCommand}
      */
     getComponent(args: GetComponentCommandInput, options?: __HttpHandlerOptions): Promise<GetComponentCommandOutput>;
     getComponent(args: GetComponentCommandInput, cb: (err: any, data?: GetComponentCommandOutput) => void): void;
     getComponent(args: GetComponentCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: GetComponentCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Gets the pre-signed URL to download a public or a Lambda component artifact. Core devices
-     *       call this operation to identify the URL that they can use to download an artifact to
-     *       install.</p>
+     * @see {@link GetComponentVersionArtifactCommand}
      */
     getComponentVersionArtifact(args: GetComponentVersionArtifactCommandInput, options?: __HttpHandlerOptions): Promise<GetComponentVersionArtifactCommandOutput>;
     getComponentVersionArtifact(args: GetComponentVersionArtifactCommandInput, cb: (err: any, data?: GetComponentVersionArtifactCommandOutput) => void): void;
     getComponentVersionArtifact(args: GetComponentVersionArtifactCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: GetComponentVersionArtifactCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Retrieves connectivity information for a Greengrass core device.</p>
-     *          <p>Connectivity information includes endpoints and ports where client devices
-     *       can connect to an MQTT broker on the core device. When a client device
-     *       calls the <a href="https://docs.aws.amazon.com/greengrass/v2/developerguide/greengrass-discover-api.html">IoT Greengrass discovery API</a>,
-     *       IoT Greengrass returns connectivity information for all of the core devices where the client device can
-     *       connect. For more information, see <a href="https://docs.aws.amazon.com/greengrass/v2/developerguide/connect-client-devices.html">Connect client devices to
-     *         core devices</a> in the <i>IoT Greengrass Version 2 Developer Guide</i>.</p>
+     * @see {@link GetConnectivityInfoCommand}
      */
     getConnectivityInfo(args: GetConnectivityInfoCommandInput, options?: __HttpHandlerOptions): Promise<GetConnectivityInfoCommandOutput>;
     getConnectivityInfo(args: GetConnectivityInfoCommandInput, cb: (err: any, data?: GetConnectivityInfoCommandOutput) => void): void;
     getConnectivityInfo(args: GetConnectivityInfoCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: GetConnectivityInfoCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Retrieves metadata for a Greengrass core device.</p>
-     *          <note>
-     *             <p>IoT Greengrass relies on individual devices to send status updates to the Amazon Web Services Cloud. If the
-     *         IoT Greengrass Core software isn't running on the device, or if device isn't connected to the Amazon Web Services Cloud,
-     *         then the reported status of that device might not reflect its current status. The status
-     *         timestamp indicates when the device status was last updated.</p>
-     *             <p>Core devices send status updates at the following times:</p>
-     *             <ul>
-     *                <li>
-     *                   <p>When the IoT Greengrass Core software starts</p>
-     *                </li>
-     *                <li>
-     *                   <p>When the core device receives a deployment from the Amazon Web Services Cloud</p>
-     *                </li>
-     *                <li>
-     *                   <p>When the status of any component on the core device becomes
-     *             <code>BROKEN</code>
-     *                   </p>
-     *                </li>
-     *                <li>
-     *                   <p>At a <a href="https://docs.aws.amazon.com/greengrass/v2/developerguide/greengrass-nucleus-component.html#greengrass-nucleus-component-configuration-fss">regular interval that you can configure</a>, which defaults to 24 hours</p>
-     *                </li>
-     *                <li>
-     *                   <p>For IoT Greengrass Core v2.7.0, the core device sends status updates upon local deployment and
-     *             cloud deployment</p>
-     *                </li>
-     *             </ul>
-     *          </note>
+     * @see {@link GetCoreDeviceCommand}
      */
     getCoreDevice(args: GetCoreDeviceCommandInput, options?: __HttpHandlerOptions): Promise<GetCoreDeviceCommandOutput>;
     getCoreDevice(args: GetCoreDeviceCommandInput, cb: (err: any, data?: GetCoreDeviceCommandOutput) => void): void;
     getCoreDevice(args: GetCoreDeviceCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: GetCoreDeviceCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Gets a deployment. Deployments define the components that run on Greengrass core devices.</p>
+     * @see {@link GetDeploymentCommand}
      */
     getDeployment(args: GetDeploymentCommandInput, options?: __HttpHandlerOptions): Promise<GetDeploymentCommandOutput>;
     getDeployment(args: GetDeploymentCommandInput, cb: (err: any, data?: GetDeploymentCommandOutput) => void): void;
     getDeployment(args: GetDeploymentCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: GetDeploymentCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Gets the service role associated with IoT Greengrass for your Amazon Web Services account in this Amazon Web Services Region.
-     *       IoT Greengrass uses this role to verify the identity of client devices and manage core device
-     *       connectivity information. For more information, see <a href="https://docs.aws.amazon.com/greengrass/v2/developerguide/greengrass-service-role.html">Greengrass service role</a> in
-     *       the <i>IoT Greengrass Version 2 Developer Guide</i>.</p>
+     * @see {@link GetServiceRoleForAccountCommand}
      */
     getServiceRoleForAccount(args: GetServiceRoleForAccountCommandInput, options?: __HttpHandlerOptions): Promise<GetServiceRoleForAccountCommandOutput>;
     getServiceRoleForAccount(args: GetServiceRoleForAccountCommandInput, cb: (err: any, data?: GetServiceRoleForAccountCommandOutput) => void): void;
     getServiceRoleForAccount(args: GetServiceRoleForAccountCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: GetServiceRoleForAccountCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Retrieves a paginated list of client devices that are associated with a core
-     *       device.</p>
+     * @see {@link ListClientDevicesAssociatedWithCoreDeviceCommand}
      */
     listClientDevicesAssociatedWithCoreDevice(args: ListClientDevicesAssociatedWithCoreDeviceCommandInput, options?: __HttpHandlerOptions): Promise<ListClientDevicesAssociatedWithCoreDeviceCommandOutput>;
     listClientDevicesAssociatedWithCoreDevice(args: ListClientDevicesAssociatedWithCoreDeviceCommandInput, cb: (err: any, data?: ListClientDevicesAssociatedWithCoreDeviceCommandOutput) => void): void;
     listClientDevicesAssociatedWithCoreDevice(args: ListClientDevicesAssociatedWithCoreDeviceCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ListClientDevicesAssociatedWithCoreDeviceCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Retrieves a paginated list of component summaries. This list includes components that you
-     *       have permission to view.</p>
+     * @see {@link ListComponentsCommand}
      */
     listComponents(args: ListComponentsCommandInput, options?: __HttpHandlerOptions): Promise<ListComponentsCommandOutput>;
     listComponents(args: ListComponentsCommandInput, cb: (err: any, data?: ListComponentsCommandOutput) => void): void;
     listComponents(args: ListComponentsCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ListComponentsCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Retrieves a paginated list of all versions for a component. Greater versions are listed
-     *       first.</p>
+     * @see {@link ListComponentVersionsCommand}
      */
     listComponentVersions(args: ListComponentVersionsCommandInput, options?: __HttpHandlerOptions): Promise<ListComponentVersionsCommandOutput>;
     listComponentVersions(args: ListComponentVersionsCommandInput, cb: (err: any, data?: ListComponentVersionsCommandOutput) => void): void;
     listComponentVersions(args: ListComponentVersionsCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ListComponentVersionsCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Retrieves a paginated list of Greengrass core devices.</p>
-     *          <note>
-     *             <p>IoT Greengrass relies on individual devices to send status updates to the Amazon Web Services Cloud. If the
-     *         IoT Greengrass Core software isn't running on the device, or if device isn't connected to the Amazon Web Services Cloud,
-     *         then the reported status of that device might not reflect its current status. The status
-     *         timestamp indicates when the device status was last updated.</p>
-     *             <p>Core devices send status updates at the following times:</p>
-     *             <ul>
-     *                <li>
-     *                   <p>When the IoT Greengrass Core software starts</p>
-     *                </li>
-     *                <li>
-     *                   <p>When the core device receives a deployment from the Amazon Web Services Cloud</p>
-     *                </li>
-     *                <li>
-     *                   <p>When the status of any component on the core device becomes
-     *             <code>BROKEN</code>
-     *                   </p>
-     *                </li>
-     *                <li>
-     *                   <p>At a <a href="https://docs.aws.amazon.com/greengrass/v2/developerguide/greengrass-nucleus-component.html#greengrass-nucleus-component-configuration-fss">regular interval that you can configure</a>, which defaults to 24 hours</p>
-     *                </li>
-     *                <li>
-     *                   <p>For IoT Greengrass Core v2.7.0, the core device sends status updates upon local deployment and
-     *             cloud deployment</p>
-     *                </li>
-     *             </ul>
-     *          </note>
+     * @see {@link ListCoreDevicesCommand}
      */
     listCoreDevices(args: ListCoreDevicesCommandInput, options?: __HttpHandlerOptions): Promise<ListCoreDevicesCommandOutput>;
     listCoreDevices(args: ListCoreDevicesCommandInput, cb: (err: any, data?: ListCoreDevicesCommandOutput) => void): void;
     listCoreDevices(args: ListCoreDevicesCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ListCoreDevicesCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Retrieves a paginated list of deployments.</p>
+     * @see {@link ListDeploymentsCommand}
      */
     listDeployments(args: ListDeploymentsCommandInput, options?: __HttpHandlerOptions): Promise<ListDeploymentsCommandOutput>;
     listDeployments(args: ListDeploymentsCommandInput, cb: (err: any, data?: ListDeploymentsCommandOutput) => void): void;
     listDeployments(args: ListDeploymentsCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ListDeploymentsCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Retrieves a paginated list of deployment jobs that IoT Greengrass sends to Greengrass core devices.</p>
+     * @see {@link ListEffectiveDeploymentsCommand}
      */
     listEffectiveDeployments(args: ListEffectiveDeploymentsCommandInput, options?: __HttpHandlerOptions): Promise<ListEffectiveDeploymentsCommandOutput>;
     listEffectiveDeployments(args: ListEffectiveDeploymentsCommandInput, cb: (err: any, data?: ListEffectiveDeploymentsCommandOutput) => void): void;
     listEffectiveDeployments(args: ListEffectiveDeploymentsCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ListEffectiveDeploymentsCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Retrieves a paginated list of the components that a Greengrass core device runs. By default,
-     *       this list doesn't include components that are deployed as dependencies of other components. To
-     *       include dependencies in the response, set the <code>topologyFilter</code> parameter to
-     *         <code>ALL</code>.</p>
-     *          <note>
-     *             <p>IoT Greengrass relies on individual devices to send status updates to the Amazon Web Services Cloud. If the
-     *         IoT Greengrass Core software isn't running on the device, or if device isn't connected to the Amazon Web Services Cloud,
-     *         then the reported status of that device might not reflect its current status. The status
-     *         timestamp indicates when the device status was last updated.</p>
-     *             <p>Core devices send status updates at the following times:</p>
-     *             <ul>
-     *                <li>
-     *                   <p>When the IoT Greengrass Core software starts</p>
-     *                </li>
-     *                <li>
-     *                   <p>When the core device receives a deployment from the Amazon Web Services Cloud</p>
-     *                </li>
-     *                <li>
-     *                   <p>When the status of any component on the core device becomes
-     *             <code>BROKEN</code>
-     *                   </p>
-     *                </li>
-     *                <li>
-     *                   <p>At a <a href="https://docs.aws.amazon.com/greengrass/v2/developerguide/greengrass-nucleus-component.html#greengrass-nucleus-component-configuration-fss">regular interval that you can configure</a>, which defaults to 24 hours</p>
-     *                </li>
-     *                <li>
-     *                   <p>For IoT Greengrass Core v2.7.0, the core device sends status updates upon local deployment and
-     *             cloud deployment</p>
-     *                </li>
-     *             </ul>
-     *          </note>
+     * @see {@link ListInstalledComponentsCommand}
      */
     listInstalledComponents(args: ListInstalledComponentsCommandInput, options?: __HttpHandlerOptions): Promise<ListInstalledComponentsCommandOutput>;
     listInstalledComponents(args: ListInstalledComponentsCommandInput, cb: (err: any, data?: ListInstalledComponentsCommandOutput) => void): void;
     listInstalledComponents(args: ListInstalledComponentsCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ListInstalledComponentsCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Retrieves the list of tags for an IoT Greengrass resource.</p>
+     * @see {@link ListTagsForResourceCommand}
      */
     listTagsForResource(args: ListTagsForResourceCommandInput, options?: __HttpHandlerOptions): Promise<ListTagsForResourceCommandOutput>;
     listTagsForResource(args: ListTagsForResourceCommandInput, cb: (err: any, data?: ListTagsForResourceCommandOutput) => void): void;
     listTagsForResource(args: ListTagsForResourceCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ListTagsForResourceCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Retrieves a list of components that meet the component, version, and platform requirements
-     *       of a deployment. Greengrass core devices call this operation when they receive a deployment to
-     *       identify the components to install.</p>
-     *          <p>This operation identifies components that meet all dependency requirements for a
-     *       deployment. If the requirements conflict, then this operation returns an error and the
-     *       deployment fails. For example, this occurs if component <code>A</code> requires version
-     *         <code>>2.0.0</code> and component <code>B</code> requires version <code><2.0.0</code>
-     *       of a component dependency.</p>
-     *          <p>When you specify the component candidates to resolve, IoT Greengrass compares each component's
-     *       digest from the core device with the component's digest in the Amazon Web Services Cloud. If the digests
-     *       don't match, then IoT Greengrass specifies to use the version from the Amazon Web Services Cloud.</p>
-     *          <important>
-     *             <p>To use this operation, you must use the data plane API endpoint and authenticate with an
-     *         IoT device certificate. For more information, see <a href="https://docs.aws.amazon.com/general/latest/gr/greengrass.html">IoT Greengrass endpoints and quotas</a>.</p>
-     *          </important>
+     * @see {@link ResolveComponentCandidatesCommand}
      */
     resolveComponentCandidates(args: ResolveComponentCandidatesCommandInput, options?: __HttpHandlerOptions): Promise<ResolveComponentCandidatesCommandOutput>;
     resolveComponentCandidates(args: ResolveComponentCandidatesCommandInput, cb: (err: any, data?: ResolveComponentCandidatesCommandOutput) => void): void;
     resolveComponentCandidates(args: ResolveComponentCandidatesCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ResolveComponentCandidatesCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Adds tags to an IoT Greengrass resource. If a tag already exists for the resource, this operation
-     *       updates the tag's value.</p>
+     * @see {@link TagResourceCommand}
      */
     tagResource(args: TagResourceCommandInput, options?: __HttpHandlerOptions): Promise<TagResourceCommandOutput>;
     tagResource(args: TagResourceCommandInput, cb: (err: any, data?: TagResourceCommandOutput) => void): void;
     tagResource(args: TagResourceCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: TagResourceCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Removes a tag from an IoT Greengrass resource.</p>
+     * @see {@link UntagResourceCommand}
      */
     untagResource(args: UntagResourceCommandInput, options?: __HttpHandlerOptions): Promise<UntagResourceCommandOutput>;
     untagResource(args: UntagResourceCommandInput, cb: (err: any, data?: UntagResourceCommandOutput) => void): void;
     untagResource(args: UntagResourceCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: UntagResourceCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Updates connectivity information for a Greengrass core device.</p>
-     *          <p>Connectivity information includes endpoints and ports where client devices
-     *       can connect to an MQTT broker on the core device. When a client device
-     *       calls the <a href="https://docs.aws.amazon.com/greengrass/v2/developerguide/greengrass-discover-api.html">IoT Greengrass discovery API</a>,
-     *       IoT Greengrass returns connectivity information for all of the core devices where the client device can
-     *       connect. For more information, see <a href="https://docs.aws.amazon.com/greengrass/v2/developerguide/connect-client-devices.html">Connect client devices to
-     *         core devices</a> in the <i>IoT Greengrass Version 2 Developer Guide</i>.</p>
+     * @see {@link UpdateConnectivityInfoCommand}
      */
     updateConnectivityInfo(args: UpdateConnectivityInfoCommandInput, options?: __HttpHandlerOptions): Promise<UpdateConnectivityInfoCommandOutput>;
     updateConnectivityInfo(args: UpdateConnectivityInfoCommandInput, cb: (err: any, data?: UpdateConnectivityInfoCommandOutput) => void): void;
     updateConnectivityInfo(args: UpdateConnectivityInfoCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: UpdateConnectivityInfoCommandOutput) => void): void;
 }
+/**
+ * @public
+ * <p>IoT Greengrass brings local compute, messaging, data management, sync, and ML inference capabilities
+ *       to edge devices. This enables devices to collect and analyze data closer to the source of
+ *       information, react autonomously to local events, and communicate securely with each other on
+ *       local networks. Local devices can also communicate securely with Amazon Web Services IoT Core and export IoT data
+ *       to the Amazon Web Services Cloud. IoT Greengrass developers can use Lambda functions and components to create and
+ *       deploy applications to fleets of edge devices for local operation.</p>
+ *          <p>IoT Greengrass Version 2 provides a new major version of the IoT Greengrass Core software, new APIs, and a new console.
+ *       Use this API reference to learn how to use the IoT Greengrass V2 API operations to manage components,
+ *       manage deployments, and core devices.</p>
+ *          <p>For more information, see <a href="https://docs.aws.amazon.com/greengrass/v2/developerguide/what-is-iot-greengrass.html">What is IoT Greengrass?</a> in the
+ *         <i>IoT Greengrass V2 Developer Guide</i>.</p>
+ */
+export declare class GreengrassV2 extends GreengrassV2Client implements GreengrassV2 {
+}

package/dist-types/ts3.4/GreengrassV2.d.ts

@@ -116,7 +116,7 @@ import {
   UpdateConnectivityInfoCommandOutput,
 } from "./commands/UpdateConnectivityInfoCommand";
 import { GreengrassV2Client } from "./GreengrassV2Client";
-export declare class GreengrassV2 extends GreengrassV2Client {
+export interface GreengrassV2 {
   associateServiceRoleToAccount(
     args: AssociateServiceRoleToAccountCommandInput,
     options?: __HttpHandlerOptions
@@ -519,3 +519,6 @@ export declare class GreengrassV2 extends GreengrassV2Client {
     cb: (err: any, data?: UpdateConnectivityInfoCommandOutput) => void
   ): void;
 }
+export declare class GreengrassV2
+  extends GreengrassV2Client
+  implements GreengrassV2 {}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@aws-sdk/client-greengrassv2",
   "description": "AWS SDK for JavaScript Greengrassv2 Client for Node.js, Browser and React Native",
-  "version": "3.315.0",
+  "version": "3.319.0",
   "scripts": {
     "build": "concurrently 'yarn:build:cjs' 'yarn:build:es' 'yarn:build:types'",
     "build:cjs": "tsc -p tsconfig.cjs.json",
@@ -21,9 +21,9 @@
   "dependencies": {
     "@aws-crypto/sha256-browser": "3.0.0",
     "@aws-crypto/sha256-js": "3.0.0",
-    "@aws-sdk/client-sts": "3.315.0",
+    "@aws-sdk/client-sts": "3.319.0",
     "@aws-sdk/config-resolver": "3.310.0",
-    "@aws-sdk/credential-provider-node": "3.315.0",
+    "@aws-sdk/credential-provider-node": "3.319.0",
     "@aws-sdk/fetch-http-handler": "3.310.0",
     "@aws-sdk/hash-node": "3.310.0",
     "@aws-sdk/invalid-dependency": "3.310.0",
@@ -36,19 +36,19 @@
     "@aws-sdk/middleware-serde": "3.310.0",
     "@aws-sdk/middleware-signing": "3.310.0",
     "@aws-sdk/middleware-stack": "3.310.0",
-    "@aws-sdk/middleware-user-agent": "3.310.0",
+    "@aws-sdk/middleware-user-agent": "3.319.0",
     "@aws-sdk/node-config-provider": "3.310.0",
     "@aws-sdk/node-http-handler": "3.310.0",
     "@aws-sdk/protocol-http": "3.310.0",
-    "@aws-sdk/smithy-client": "3.315.0",
+    "@aws-sdk/smithy-client": "3.316.0",
     "@aws-sdk/types": "3.310.0",
     "@aws-sdk/url-parser": "3.310.0",
     "@aws-sdk/util-base64": "3.310.0",
     "@aws-sdk/util-body-length-browser": "3.310.0",
     "@aws-sdk/util-body-length-node": "3.310.0",
-    "@aws-sdk/util-defaults-mode-browser": "3.315.0",
-    "@aws-sdk/util-defaults-mode-node": "3.315.0",
-    "@aws-sdk/util-endpoints": "3.310.0",
+    "@aws-sdk/util-defaults-mode-browser": "3.316.0",
+    "@aws-sdk/util-defaults-mode-node": "3.316.0",
+    "@aws-sdk/util-endpoints": "3.319.0",
     "@aws-sdk/util-retry": "3.310.0",
     "@aws-sdk/util-user-agent-browser": "3.310.0",
     "@aws-sdk/util-user-agent-node": "3.310.0",