@aws-sdk/client-greengrass 3.31.0 → 3.35.0

package/dist-types/commands/DeleteResourceDefinitionCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { GreengrassClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../GreengrassClient";
+import { DeleteResourceDefinitionRequest, DeleteResourceDefinitionResponse } from "../models/models_0";
+export interface DeleteResourceDefinitionCommandInput extends DeleteResourceDefinitionRequest {
+}
+export interface DeleteResourceDefinitionCommandOutput extends DeleteResourceDefinitionResponse, __MetadataBearer {
+}
+/**
+ * Deletes a resource definition.
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { GreengrassClient, DeleteResourceDefinitionCommand } from "@aws-sdk/client-greengrass"; // ES Modules import
+ * // const { GreengrassClient, DeleteResourceDefinitionCommand } = require("@aws-sdk/client-greengrass"); // CommonJS import
+ * const client = new GreengrassClient(config);
+ * const command = new DeleteResourceDefinitionCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DeleteResourceDefinitionCommandInput} for command's `input` shape.
+ * @see {@link DeleteResourceDefinitionCommandOutput} for command's `response` shape.
+ * @see {@link GreengrassClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class DeleteResourceDefinitionCommand extends $Command<DeleteResourceDefinitionCommandInput, DeleteResourceDefinitionCommandOutput, GreengrassClientResolvedConfig> {
+    readonly input: DeleteResourceDefinitionCommandInput;
+    constructor(input: DeleteResourceDefinitionCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GreengrassClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteResourceDefinitionCommandInput, DeleteResourceDefinitionCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/DeleteSubscriptionDefinitionCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { GreengrassClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../GreengrassClient";
+import { DeleteSubscriptionDefinitionRequest, DeleteSubscriptionDefinitionResponse } from "../models/models_0";
+export interface DeleteSubscriptionDefinitionCommandInput extends DeleteSubscriptionDefinitionRequest {
+}
+export interface DeleteSubscriptionDefinitionCommandOutput extends DeleteSubscriptionDefinitionResponse, __MetadataBearer {
+}
+/**
+ * Deletes a subscription definition.
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { GreengrassClient, DeleteSubscriptionDefinitionCommand } from "@aws-sdk/client-greengrass"; // ES Modules import
+ * // const { GreengrassClient, DeleteSubscriptionDefinitionCommand } = require("@aws-sdk/client-greengrass"); // CommonJS import
+ * const client = new GreengrassClient(config);
+ * const command = new DeleteSubscriptionDefinitionCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DeleteSubscriptionDefinitionCommandInput} for command's `input` shape.
+ * @see {@link DeleteSubscriptionDefinitionCommandOutput} for command's `response` shape.
+ * @see {@link GreengrassClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class DeleteSubscriptionDefinitionCommand extends $Command<DeleteSubscriptionDefinitionCommandInput, DeleteSubscriptionDefinitionCommandOutput, GreengrassClientResolvedConfig> {
+    readonly input: DeleteSubscriptionDefinitionCommandInput;
+    constructor(input: DeleteSubscriptionDefinitionCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GreengrassClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteSubscriptionDefinitionCommandInput, DeleteSubscriptionDefinitionCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/DisassociateRoleFromGroupCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { GreengrassClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../GreengrassClient";
+import { DisassociateRoleFromGroupRequest, DisassociateRoleFromGroupResponse } from "../models/models_0";
+export interface DisassociateRoleFromGroupCommandInput extends DisassociateRoleFromGroupRequest {
+}
+export interface DisassociateRoleFromGroupCommandOutput extends DisassociateRoleFromGroupResponse, __MetadataBearer {
+}
+/**
+ * Disassociates the role from a group.
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { GreengrassClient, DisassociateRoleFromGroupCommand } from "@aws-sdk/client-greengrass"; // ES Modules import
+ * // const { GreengrassClient, DisassociateRoleFromGroupCommand } = require("@aws-sdk/client-greengrass"); // CommonJS import
+ * const client = new GreengrassClient(config);
+ * const command = new DisassociateRoleFromGroupCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DisassociateRoleFromGroupCommandInput} for command's `input` shape.
+ * @see {@link DisassociateRoleFromGroupCommandOutput} for command's `response` shape.
+ * @see {@link GreengrassClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class DisassociateRoleFromGroupCommand extends $Command<DisassociateRoleFromGroupCommandInput, DisassociateRoleFromGroupCommandOutput, GreengrassClientResolvedConfig> {
+    readonly input: DisassociateRoleFromGroupCommandInput;
+    constructor(input: DisassociateRoleFromGroupCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GreengrassClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DisassociateRoleFromGroupCommandInput, DisassociateRoleFromGroupCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/DisassociateServiceRoleFromAccountCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { GreengrassClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../GreengrassClient";
+import { DisassociateServiceRoleFromAccountRequest, DisassociateServiceRoleFromAccountResponse } from "../models/models_0";
+export interface DisassociateServiceRoleFromAccountCommandInput extends DisassociateServiceRoleFromAccountRequest {
+}
+export interface DisassociateServiceRoleFromAccountCommandOutput extends DisassociateServiceRoleFromAccountResponse, __MetadataBearer {
+}
+/**
+ * Disassociates the service role from your account. Without a service role, deployments will not work.
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { GreengrassClient, DisassociateServiceRoleFromAccountCommand } from "@aws-sdk/client-greengrass"; // ES Modules import
+ * // const { GreengrassClient, DisassociateServiceRoleFromAccountCommand } = require("@aws-sdk/client-greengrass"); // CommonJS import
+ * const client = new GreengrassClient(config);
+ * const command = new DisassociateServiceRoleFromAccountCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DisassociateServiceRoleFromAccountCommandInput} for command's `input` shape.
+ * @see {@link DisassociateServiceRoleFromAccountCommandOutput} for command's `response` shape.
+ * @see {@link GreengrassClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class DisassociateServiceRoleFromAccountCommand extends $Command<DisassociateServiceRoleFromAccountCommandInput, DisassociateServiceRoleFromAccountCommandOutput, GreengrassClientResolvedConfig> {
+    readonly input: DisassociateServiceRoleFromAccountCommandInput;
+    constructor(input: DisassociateServiceRoleFromAccountCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GreengrassClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DisassociateServiceRoleFromAccountCommandInput, DisassociateServiceRoleFromAccountCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetAssociatedRoleCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { GreengrassClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../GreengrassClient";
+import { GetAssociatedRoleRequest, GetAssociatedRoleResponse } from "../models/models_0";
+export interface GetAssociatedRoleCommandInput extends GetAssociatedRoleRequest {
+}
+export interface GetAssociatedRoleCommandOutput extends GetAssociatedRoleResponse, __MetadataBearer {
+}
+/**
+ * Retrieves the role associated with a particular group.
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { GreengrassClient, GetAssociatedRoleCommand } from "@aws-sdk/client-greengrass"; // ES Modules import
+ * // const { GreengrassClient, GetAssociatedRoleCommand } = require("@aws-sdk/client-greengrass"); // CommonJS import
+ * const client = new GreengrassClient(config);
+ * const command = new GetAssociatedRoleCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetAssociatedRoleCommandInput} for command's `input` shape.
+ * @see {@link GetAssociatedRoleCommandOutput} for command's `response` shape.
+ * @see {@link GreengrassClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetAssociatedRoleCommand extends $Command<GetAssociatedRoleCommandInput, GetAssociatedRoleCommandOutput, GreengrassClientResolvedConfig> {
+    readonly input: GetAssociatedRoleCommandInput;
+    constructor(input: GetAssociatedRoleCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GreengrassClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetAssociatedRoleCommandInput, GetAssociatedRoleCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetBulkDeploymentStatusCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { GreengrassClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../GreengrassClient";
+import { GetBulkDeploymentStatusRequest, GetBulkDeploymentStatusResponse } from "../models/models_0";
+export interface GetBulkDeploymentStatusCommandInput extends GetBulkDeploymentStatusRequest {
+}
+export interface GetBulkDeploymentStatusCommandOutput extends GetBulkDeploymentStatusResponse, __MetadataBearer {
+}
+/**
+ * Returns the status of a bulk deployment.
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { GreengrassClient, GetBulkDeploymentStatusCommand } from "@aws-sdk/client-greengrass"; // ES Modules import
+ * // const { GreengrassClient, GetBulkDeploymentStatusCommand } = require("@aws-sdk/client-greengrass"); // CommonJS import
+ * const client = new GreengrassClient(config);
+ * const command = new GetBulkDeploymentStatusCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetBulkDeploymentStatusCommandInput} for command's `input` shape.
+ * @see {@link GetBulkDeploymentStatusCommandOutput} for command's `response` shape.
+ * @see {@link GreengrassClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetBulkDeploymentStatusCommand extends $Command<GetBulkDeploymentStatusCommandInput, GetBulkDeploymentStatusCommandOutput, GreengrassClientResolvedConfig> {
+    readonly input: GetBulkDeploymentStatusCommandInput;
+    constructor(input: GetBulkDeploymentStatusCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GreengrassClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetBulkDeploymentStatusCommandInput, GetBulkDeploymentStatusCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetConnectivityInfoCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { GreengrassClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../GreengrassClient";
+import { GetConnectivityInfoRequest, GetConnectivityInfoResponse } from "../models/models_0";
+export interface GetConnectivityInfoCommandInput extends GetConnectivityInfoRequest {
+}
+export interface GetConnectivityInfoCommandOutput extends GetConnectivityInfoResponse, __MetadataBearer {
+}
+/**
+ * Retrieves the connectivity information for a core.
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { GreengrassClient, GetConnectivityInfoCommand } from "@aws-sdk/client-greengrass"; // ES Modules import
+ * // const { GreengrassClient, GetConnectivityInfoCommand } = require("@aws-sdk/client-greengrass"); // CommonJS import
+ * const client = new GreengrassClient(config);
+ * const command = new GetConnectivityInfoCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetConnectivityInfoCommandInput} for command's `input` shape.
+ * @see {@link GetConnectivityInfoCommandOutput} for command's `response` shape.
+ * @see {@link GreengrassClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetConnectivityInfoCommand extends $Command<GetConnectivityInfoCommandInput, GetConnectivityInfoCommandOutput, GreengrassClientResolvedConfig> {
+    readonly input: GetConnectivityInfoCommandInput;
+    constructor(input: GetConnectivityInfoCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GreengrassClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetConnectivityInfoCommandInput, GetConnectivityInfoCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetConnectorDefinitionCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { GreengrassClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../GreengrassClient";
+import { GetConnectorDefinitionRequest, GetConnectorDefinitionResponse } from "../models/models_0";
+export interface GetConnectorDefinitionCommandInput extends GetConnectorDefinitionRequest {
+}
+export interface GetConnectorDefinitionCommandOutput extends GetConnectorDefinitionResponse, __MetadataBearer {
+}
+/**
+ * Retrieves information about a connector definition.
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { GreengrassClient, GetConnectorDefinitionCommand } from "@aws-sdk/client-greengrass"; // ES Modules import
+ * // const { GreengrassClient, GetConnectorDefinitionCommand } = require("@aws-sdk/client-greengrass"); // CommonJS import
+ * const client = new GreengrassClient(config);
+ * const command = new GetConnectorDefinitionCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetConnectorDefinitionCommandInput} for command's `input` shape.
+ * @see {@link GetConnectorDefinitionCommandOutput} for command's `response` shape.
+ * @see {@link GreengrassClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetConnectorDefinitionCommand extends $Command<GetConnectorDefinitionCommandInput, GetConnectorDefinitionCommandOutput, GreengrassClientResolvedConfig> {
+    readonly input: GetConnectorDefinitionCommandInput;
+    constructor(input: GetConnectorDefinitionCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GreengrassClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetConnectorDefinitionCommandInput, GetConnectorDefinitionCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetConnectorDefinitionVersionCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { GreengrassClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../GreengrassClient";
+import { GetConnectorDefinitionVersionRequest, GetConnectorDefinitionVersionResponse } from "../models/models_0";
+export interface GetConnectorDefinitionVersionCommandInput extends GetConnectorDefinitionVersionRequest {
+}
+export interface GetConnectorDefinitionVersionCommandOutput extends GetConnectorDefinitionVersionResponse, __MetadataBearer {
+}
+/**
+ * Retrieves information about a connector definition version, including the connectors that the version contains. Connectors are prebuilt modules that interact with local infrastructure, device protocols, AWS, and other cloud services.
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { GreengrassClient, GetConnectorDefinitionVersionCommand } from "@aws-sdk/client-greengrass"; // ES Modules import
+ * // const { GreengrassClient, GetConnectorDefinitionVersionCommand } = require("@aws-sdk/client-greengrass"); // CommonJS import
+ * const client = new GreengrassClient(config);
+ * const command = new GetConnectorDefinitionVersionCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetConnectorDefinitionVersionCommandInput} for command's `input` shape.
+ * @see {@link GetConnectorDefinitionVersionCommandOutput} for command's `response` shape.
+ * @see {@link GreengrassClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetConnectorDefinitionVersionCommand extends $Command<GetConnectorDefinitionVersionCommandInput, GetConnectorDefinitionVersionCommandOutput, GreengrassClientResolvedConfig> {
+    readonly input: GetConnectorDefinitionVersionCommandInput;
+    constructor(input: GetConnectorDefinitionVersionCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GreengrassClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetConnectorDefinitionVersionCommandInput, GetConnectorDefinitionVersionCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetCoreDefinitionCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { GreengrassClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../GreengrassClient";
+import { GetCoreDefinitionRequest, GetCoreDefinitionResponse } from "../models/models_0";
+export interface GetCoreDefinitionCommandInput extends GetCoreDefinitionRequest {
+}
+export interface GetCoreDefinitionCommandOutput extends GetCoreDefinitionResponse, __MetadataBearer {
+}
+/**
+ * Retrieves information about a core definition version.
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { GreengrassClient, GetCoreDefinitionCommand } from "@aws-sdk/client-greengrass"; // ES Modules import
+ * // const { GreengrassClient, GetCoreDefinitionCommand } = require("@aws-sdk/client-greengrass"); // CommonJS import
+ * const client = new GreengrassClient(config);
+ * const command = new GetCoreDefinitionCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetCoreDefinitionCommandInput} for command's `input` shape.
+ * @see {@link GetCoreDefinitionCommandOutput} for command's `response` shape.
+ * @see {@link GreengrassClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetCoreDefinitionCommand extends $Command<GetCoreDefinitionCommandInput, GetCoreDefinitionCommandOutput, GreengrassClientResolvedConfig> {
+    readonly input: GetCoreDefinitionCommandInput;
+    constructor(input: GetCoreDefinitionCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GreengrassClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetCoreDefinitionCommandInput, GetCoreDefinitionCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetCoreDefinitionVersionCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { GreengrassClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../GreengrassClient";
+import { GetCoreDefinitionVersionRequest, GetCoreDefinitionVersionResponse } from "../models/models_0";
+export interface GetCoreDefinitionVersionCommandInput extends GetCoreDefinitionVersionRequest {
+}
+export interface GetCoreDefinitionVersionCommandOutput extends GetCoreDefinitionVersionResponse, __MetadataBearer {
+}
+/**
+ * Retrieves information about a core definition version.
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { GreengrassClient, GetCoreDefinitionVersionCommand } from "@aws-sdk/client-greengrass"; // ES Modules import
+ * // const { GreengrassClient, GetCoreDefinitionVersionCommand } = require("@aws-sdk/client-greengrass"); // CommonJS import
+ * const client = new GreengrassClient(config);
+ * const command = new GetCoreDefinitionVersionCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetCoreDefinitionVersionCommandInput} for command's `input` shape.
+ * @see {@link GetCoreDefinitionVersionCommandOutput} for command's `response` shape.
+ * @see {@link GreengrassClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetCoreDefinitionVersionCommand extends $Command<GetCoreDefinitionVersionCommandInput, GetCoreDefinitionVersionCommandOutput, GreengrassClientResolvedConfig> {
+    readonly input: GetCoreDefinitionVersionCommandInput;
+    constructor(input: GetCoreDefinitionVersionCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GreengrassClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetCoreDefinitionVersionCommandInput, GetCoreDefinitionVersionCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetDeploymentStatusCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { GreengrassClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../GreengrassClient";
+import { GetDeploymentStatusRequest, GetDeploymentStatusResponse } from "../models/models_0";
+export interface GetDeploymentStatusCommandInput extends GetDeploymentStatusRequest {
+}
+export interface GetDeploymentStatusCommandOutput extends GetDeploymentStatusResponse, __MetadataBearer {
+}
+/**
+ * Returns the status of a deployment.
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { GreengrassClient, GetDeploymentStatusCommand } from "@aws-sdk/client-greengrass"; // ES Modules import
+ * // const { GreengrassClient, GetDeploymentStatusCommand } = require("@aws-sdk/client-greengrass"); // CommonJS import
+ * const client = new GreengrassClient(config);
+ * const command = new GetDeploymentStatusCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetDeploymentStatusCommandInput} for command's `input` shape.
+ * @see {@link GetDeploymentStatusCommandOutput} for command's `response` shape.
+ * @see {@link GreengrassClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetDeploymentStatusCommand extends $Command<GetDeploymentStatusCommandInput, GetDeploymentStatusCommandOutput, GreengrassClientResolvedConfig> {
+    readonly input: GetDeploymentStatusCommandInput;
+    constructor(input: GetDeploymentStatusCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GreengrassClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetDeploymentStatusCommandInput, GetDeploymentStatusCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetDeviceDefinitionCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { GreengrassClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../GreengrassClient";
+import { GetDeviceDefinitionRequest, GetDeviceDefinitionResponse } from "../models/models_0";
+export interface GetDeviceDefinitionCommandInput extends GetDeviceDefinitionRequest {
+}
+export interface GetDeviceDefinitionCommandOutput extends GetDeviceDefinitionResponse, __MetadataBearer {
+}
+/**
+ * Retrieves information about a device definition.
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { GreengrassClient, GetDeviceDefinitionCommand } from "@aws-sdk/client-greengrass"; // ES Modules import
+ * // const { GreengrassClient, GetDeviceDefinitionCommand } = require("@aws-sdk/client-greengrass"); // CommonJS import
+ * const client = new GreengrassClient(config);
+ * const command = new GetDeviceDefinitionCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetDeviceDefinitionCommandInput} for command's `input` shape.
+ * @see {@link GetDeviceDefinitionCommandOutput} for command's `response` shape.
+ * @see {@link GreengrassClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetDeviceDefinitionCommand extends $Command<GetDeviceDefinitionCommandInput, GetDeviceDefinitionCommandOutput, GreengrassClientResolvedConfig> {
+    readonly input: GetDeviceDefinitionCommandInput;
+    constructor(input: GetDeviceDefinitionCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GreengrassClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetDeviceDefinitionCommandInput, GetDeviceDefinitionCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetDeviceDefinitionVersionCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { GreengrassClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../GreengrassClient";
+import { GetDeviceDefinitionVersionRequest, GetDeviceDefinitionVersionResponse } from "../models/models_0";
+export interface GetDeviceDefinitionVersionCommandInput extends GetDeviceDefinitionVersionRequest {
+}
+export interface GetDeviceDefinitionVersionCommandOutput extends GetDeviceDefinitionVersionResponse, __MetadataBearer {
+}
+/**
+ * Retrieves information about a device definition version.
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { GreengrassClient, GetDeviceDefinitionVersionCommand } from "@aws-sdk/client-greengrass"; // ES Modules import
+ * // const { GreengrassClient, GetDeviceDefinitionVersionCommand } = require("@aws-sdk/client-greengrass"); // CommonJS import
+ * const client = new GreengrassClient(config);
+ * const command = new GetDeviceDefinitionVersionCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetDeviceDefinitionVersionCommandInput} for command's `input` shape.
+ * @see {@link GetDeviceDefinitionVersionCommandOutput} for command's `response` shape.
+ * @see {@link GreengrassClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetDeviceDefinitionVersionCommand extends $Command<GetDeviceDefinitionVersionCommandInput, GetDeviceDefinitionVersionCommandOutput, GreengrassClientResolvedConfig> {
+    readonly input: GetDeviceDefinitionVersionCommandInput;
+    constructor(input: GetDeviceDefinitionVersionCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GreengrassClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetDeviceDefinitionVersionCommandInput, GetDeviceDefinitionVersionCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetFunctionDefinitionCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { GreengrassClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../GreengrassClient";
+import { GetFunctionDefinitionRequest, GetFunctionDefinitionResponse } from "../models/models_0";
+export interface GetFunctionDefinitionCommandInput extends GetFunctionDefinitionRequest {
+}
+export interface GetFunctionDefinitionCommandOutput extends GetFunctionDefinitionResponse, __MetadataBearer {
+}
+/**
+ * Retrieves information about a Lambda function definition, including its creation time and latest version.
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { GreengrassClient, GetFunctionDefinitionCommand } from "@aws-sdk/client-greengrass"; // ES Modules import
+ * // const { GreengrassClient, GetFunctionDefinitionCommand } = require("@aws-sdk/client-greengrass"); // CommonJS import
+ * const client = new GreengrassClient(config);
+ * const command = new GetFunctionDefinitionCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetFunctionDefinitionCommandInput} for command's `input` shape.
+ * @see {@link GetFunctionDefinitionCommandOutput} for command's `response` shape.
+ * @see {@link GreengrassClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetFunctionDefinitionCommand extends $Command<GetFunctionDefinitionCommandInput, GetFunctionDefinitionCommandOutput, GreengrassClientResolvedConfig> {
+    readonly input: GetFunctionDefinitionCommandInput;
+    constructor(input: GetFunctionDefinitionCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GreengrassClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetFunctionDefinitionCommandInput, GetFunctionDefinitionCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetFunctionDefinitionVersionCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { GreengrassClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../GreengrassClient";
+import { GetFunctionDefinitionVersionRequest, GetFunctionDefinitionVersionResponse } from "../models/models_0";
+export interface GetFunctionDefinitionVersionCommandInput extends GetFunctionDefinitionVersionRequest {
+}
+export interface GetFunctionDefinitionVersionCommandOutput extends GetFunctionDefinitionVersionResponse, __MetadataBearer {
+}
+/**
+ * Retrieves information about a Lambda function definition version, including which Lambda functions are included in the version and their configurations.
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { GreengrassClient, GetFunctionDefinitionVersionCommand } from "@aws-sdk/client-greengrass"; // ES Modules import
+ * // const { GreengrassClient, GetFunctionDefinitionVersionCommand } = require("@aws-sdk/client-greengrass"); // CommonJS import
+ * const client = new GreengrassClient(config);
+ * const command = new GetFunctionDefinitionVersionCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetFunctionDefinitionVersionCommandInput} for command's `input` shape.
+ * @see {@link GetFunctionDefinitionVersionCommandOutput} for command's `response` shape.
+ * @see {@link GreengrassClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetFunctionDefinitionVersionCommand extends $Command<GetFunctionDefinitionVersionCommandInput, GetFunctionDefinitionVersionCommandOutput, GreengrassClientResolvedConfig> {
+    readonly input: GetFunctionDefinitionVersionCommandInput;
+    constructor(input: GetFunctionDefinitionVersionCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GreengrassClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetFunctionDefinitionVersionCommandInput, GetFunctionDefinitionVersionCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetGroupCertificateAuthorityCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { GreengrassClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../GreengrassClient";
+import { GetGroupCertificateAuthorityRequest, GetGroupCertificateAuthorityResponse } from "../models/models_0";
+export interface GetGroupCertificateAuthorityCommandInput extends GetGroupCertificateAuthorityRequest {
+}
+export interface GetGroupCertificateAuthorityCommandOutput extends GetGroupCertificateAuthorityResponse, __MetadataBearer {
+}
+/**
+ * Retreives the CA associated with a group. Returns the public key of the CA.
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { GreengrassClient, GetGroupCertificateAuthorityCommand } from "@aws-sdk/client-greengrass"; // ES Modules import
+ * // const { GreengrassClient, GetGroupCertificateAuthorityCommand } = require("@aws-sdk/client-greengrass"); // CommonJS import
+ * const client = new GreengrassClient(config);
+ * const command = new GetGroupCertificateAuthorityCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetGroupCertificateAuthorityCommandInput} for command's `input` shape.
+ * @see {@link GetGroupCertificateAuthorityCommandOutput} for command's `response` shape.
+ * @see {@link GreengrassClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetGroupCertificateAuthorityCommand extends $Command<GetGroupCertificateAuthorityCommandInput, GetGroupCertificateAuthorityCommandOutput, GreengrassClientResolvedConfig> {
+    readonly input: GetGroupCertificateAuthorityCommandInput;
+    constructor(input: GetGroupCertificateAuthorityCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GreengrassClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetGroupCertificateAuthorityCommandInput, GetGroupCertificateAuthorityCommandOutput>;
+    private serialize;
+    private deserialize;
+}