@aws-sdk/client-networkmanager 3.42.0 → 3.47.0

package/dist-types/commands/ExecuteCoreNetworkChangeSetCommand.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 { ExecuteCoreNetworkChangeSetRequest, ExecuteCoreNetworkChangeSetResponse } from "../models/models_0";
+import { NetworkManagerClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../NetworkManagerClient";
+export interface ExecuteCoreNetworkChangeSetCommandInput extends ExecuteCoreNetworkChangeSetRequest {
+}
+export interface ExecuteCoreNetworkChangeSetCommandOutput extends ExecuteCoreNetworkChangeSetResponse, __MetadataBearer {
+}
+/**
+ * <p>Executes a change set on your core network. Deploys changes globally based on the policy submitted..</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { NetworkManagerClient, ExecuteCoreNetworkChangeSetCommand } from "@aws-sdk/client-networkmanager"; // ES Modules import
+ * // const { NetworkManagerClient, ExecuteCoreNetworkChangeSetCommand } = require("@aws-sdk/client-networkmanager"); // CommonJS import
+ * const client = new NetworkManagerClient(config);
+ * const command = new ExecuteCoreNetworkChangeSetCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ExecuteCoreNetworkChangeSetCommandInput} for command's `input` shape.
+ * @see {@link ExecuteCoreNetworkChangeSetCommandOutput} for command's `response` shape.
+ * @see {@link NetworkManagerClientResolvedConfig | config} for NetworkManagerClient's `config` shape.
+ *
+ */
+export declare class ExecuteCoreNetworkChangeSetCommand extends $Command<ExecuteCoreNetworkChangeSetCommandInput, ExecuteCoreNetworkChangeSetCommandOutput, NetworkManagerClientResolvedConfig> {
+    readonly input: ExecuteCoreNetworkChangeSetCommandInput;
+    constructor(input: ExecuteCoreNetworkChangeSetCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: NetworkManagerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ExecuteCoreNetworkChangeSetCommandInput, ExecuteCoreNetworkChangeSetCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetConnectAttachmentCommand.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 { GetConnectAttachmentRequest, GetConnectAttachmentResponse } from "../models/models_0";
+import { NetworkManagerClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../NetworkManagerClient";
+export interface GetConnectAttachmentCommandInput extends GetConnectAttachmentRequest {
+}
+export interface GetConnectAttachmentCommandOutput extends GetConnectAttachmentResponse, __MetadataBearer {
+}
+/**
+ * <p>Returns information about a core network Connect attachment.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { NetworkManagerClient, GetConnectAttachmentCommand } from "@aws-sdk/client-networkmanager"; // ES Modules import
+ * // const { NetworkManagerClient, GetConnectAttachmentCommand } = require("@aws-sdk/client-networkmanager"); // CommonJS import
+ * const client = new NetworkManagerClient(config);
+ * const command = new GetConnectAttachmentCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetConnectAttachmentCommandInput} for command's `input` shape.
+ * @see {@link GetConnectAttachmentCommandOutput} for command's `response` shape.
+ * @see {@link NetworkManagerClientResolvedConfig | config} for NetworkManagerClient's `config` shape.
+ *
+ */
+export declare class GetConnectAttachmentCommand extends $Command<GetConnectAttachmentCommandInput, GetConnectAttachmentCommandOutput, NetworkManagerClientResolvedConfig> {
+    readonly input: GetConnectAttachmentCommandInput;
+    constructor(input: GetConnectAttachmentCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: NetworkManagerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetConnectAttachmentCommandInput, GetConnectAttachmentCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetConnectPeerAssociationsCommand.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 { GetConnectPeerAssociationsRequest, GetConnectPeerAssociationsResponse } from "../models/models_0";
+import { NetworkManagerClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../NetworkManagerClient";
+export interface GetConnectPeerAssociationsCommandInput extends GetConnectPeerAssociationsRequest {
+}
+export interface GetConnectPeerAssociationsCommandOutput extends GetConnectPeerAssociationsResponse, __MetadataBearer {
+}
+/**
+ * <p>Returns information about a core network Connect peer associations.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { NetworkManagerClient, GetConnectPeerAssociationsCommand } from "@aws-sdk/client-networkmanager"; // ES Modules import
+ * // const { NetworkManagerClient, GetConnectPeerAssociationsCommand } = require("@aws-sdk/client-networkmanager"); // CommonJS import
+ * const client = new NetworkManagerClient(config);
+ * const command = new GetConnectPeerAssociationsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetConnectPeerAssociationsCommandInput} for command's `input` shape.
+ * @see {@link GetConnectPeerAssociationsCommandOutput} for command's `response` shape.
+ * @see {@link NetworkManagerClientResolvedConfig | config} for NetworkManagerClient's `config` shape.
+ *
+ */
+export declare class GetConnectPeerAssociationsCommand extends $Command<GetConnectPeerAssociationsCommandInput, GetConnectPeerAssociationsCommandOutput, NetworkManagerClientResolvedConfig> {
+    readonly input: GetConnectPeerAssociationsCommandInput;
+    constructor(input: GetConnectPeerAssociationsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: NetworkManagerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetConnectPeerAssociationsCommandInput, GetConnectPeerAssociationsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetConnectPeerCommand.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 { GetConnectPeerRequest, GetConnectPeerResponse } from "../models/models_0";
+import { NetworkManagerClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../NetworkManagerClient";
+export interface GetConnectPeerCommandInput extends GetConnectPeerRequest {
+}
+export interface GetConnectPeerCommandOutput extends GetConnectPeerResponse, __MetadataBearer {
+}
+/**
+ * <p>Returns information about a core network Connect peer.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { NetworkManagerClient, GetConnectPeerCommand } from "@aws-sdk/client-networkmanager"; // ES Modules import
+ * // const { NetworkManagerClient, GetConnectPeerCommand } = require("@aws-sdk/client-networkmanager"); // CommonJS import
+ * const client = new NetworkManagerClient(config);
+ * const command = new GetConnectPeerCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetConnectPeerCommandInput} for command's `input` shape.
+ * @see {@link GetConnectPeerCommandOutput} for command's `response` shape.
+ * @see {@link NetworkManagerClientResolvedConfig | config} for NetworkManagerClient's `config` shape.
+ *
+ */
+export declare class GetConnectPeerCommand extends $Command<GetConnectPeerCommandInput, GetConnectPeerCommandOutput, NetworkManagerClientResolvedConfig> {
+    readonly input: GetConnectPeerCommandInput;
+    constructor(input: GetConnectPeerCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: NetworkManagerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetConnectPeerCommandInput, GetConnectPeerCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetCoreNetworkChangeSetCommand.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 { GetCoreNetworkChangeSetRequest, GetCoreNetworkChangeSetResponse } from "../models/models_0";
+import { NetworkManagerClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../NetworkManagerClient";
+export interface GetCoreNetworkChangeSetCommandInput extends GetCoreNetworkChangeSetRequest {
+}
+export interface GetCoreNetworkChangeSetCommandOutput extends GetCoreNetworkChangeSetResponse, __MetadataBearer {
+}
+/**
+ * <p>Returns a change set between the LIVE core network policy and a submitted policy.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { NetworkManagerClient, GetCoreNetworkChangeSetCommand } from "@aws-sdk/client-networkmanager"; // ES Modules import
+ * // const { NetworkManagerClient, GetCoreNetworkChangeSetCommand } = require("@aws-sdk/client-networkmanager"); // CommonJS import
+ * const client = new NetworkManagerClient(config);
+ * const command = new GetCoreNetworkChangeSetCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetCoreNetworkChangeSetCommandInput} for command's `input` shape.
+ * @see {@link GetCoreNetworkChangeSetCommandOutput} for command's `response` shape.
+ * @see {@link NetworkManagerClientResolvedConfig | config} for NetworkManagerClient's `config` shape.
+ *
+ */
+export declare class GetCoreNetworkChangeSetCommand extends $Command<GetCoreNetworkChangeSetCommandInput, GetCoreNetworkChangeSetCommandOutput, NetworkManagerClientResolvedConfig> {
+    readonly input: GetCoreNetworkChangeSetCommandInput;
+    constructor(input: GetCoreNetworkChangeSetCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: NetworkManagerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetCoreNetworkChangeSetCommandInput, GetCoreNetworkChangeSetCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetCoreNetworkCommand.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 { GetCoreNetworkRequest, GetCoreNetworkResponse } from "../models/models_0";
+import { NetworkManagerClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../NetworkManagerClient";
+export interface GetCoreNetworkCommandInput extends GetCoreNetworkRequest {
+}
+export interface GetCoreNetworkCommandOutput extends GetCoreNetworkResponse, __MetadataBearer {
+}
+/**
+ * <p>Returns information about a core network. By default it returns the LIVE policy.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { NetworkManagerClient, GetCoreNetworkCommand } from "@aws-sdk/client-networkmanager"; // ES Modules import
+ * // const { NetworkManagerClient, GetCoreNetworkCommand } = require("@aws-sdk/client-networkmanager"); // CommonJS import
+ * const client = new NetworkManagerClient(config);
+ * const command = new GetCoreNetworkCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetCoreNetworkCommandInput} for command's `input` shape.
+ * @see {@link GetCoreNetworkCommandOutput} for command's `response` shape.
+ * @see {@link NetworkManagerClientResolvedConfig | config} for NetworkManagerClient's `config` shape.
+ *
+ */
+export declare class GetCoreNetworkCommand extends $Command<GetCoreNetworkCommandInput, GetCoreNetworkCommandOutput, NetworkManagerClientResolvedConfig> {
+    readonly input: GetCoreNetworkCommandInput;
+    constructor(input: GetCoreNetworkCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: NetworkManagerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetCoreNetworkCommandInput, GetCoreNetworkCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetCoreNetworkPolicyCommand.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 { GetCoreNetworkPolicyRequest, GetCoreNetworkPolicyResponse } from "../models/models_0";
+import { NetworkManagerClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../NetworkManagerClient";
+export interface GetCoreNetworkPolicyCommandInput extends GetCoreNetworkPolicyRequest {
+}
+export interface GetCoreNetworkPolicyCommandOutput extends GetCoreNetworkPolicyResponse, __MetadataBearer {
+}
+/**
+ * <p>Gets details about a core network policy. You can get details about your current live policy or any previous policy version.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { NetworkManagerClient, GetCoreNetworkPolicyCommand } from "@aws-sdk/client-networkmanager"; // ES Modules import
+ * // const { NetworkManagerClient, GetCoreNetworkPolicyCommand } = require("@aws-sdk/client-networkmanager"); // CommonJS import
+ * const client = new NetworkManagerClient(config);
+ * const command = new GetCoreNetworkPolicyCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetCoreNetworkPolicyCommandInput} for command's `input` shape.
+ * @see {@link GetCoreNetworkPolicyCommandOutput} for command's `response` shape.
+ * @see {@link NetworkManagerClientResolvedConfig | config} for NetworkManagerClient's `config` shape.
+ *
+ */
+export declare class GetCoreNetworkPolicyCommand extends $Command<GetCoreNetworkPolicyCommandInput, GetCoreNetworkPolicyCommandOutput, NetworkManagerClientResolvedConfig> {
+    readonly input: GetCoreNetworkPolicyCommandInput;
+    constructor(input: GetCoreNetworkPolicyCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: NetworkManagerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetCoreNetworkPolicyCommandInput, GetCoreNetworkPolicyCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetResourcePolicyCommand.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 { GetResourcePolicyRequest, GetResourcePolicyResponse } from "../models/models_0";
+import { NetworkManagerClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../NetworkManagerClient";
+export interface GetResourcePolicyCommandInput extends GetResourcePolicyRequest {
+}
+export interface GetResourcePolicyCommandOutput extends GetResourcePolicyResponse, __MetadataBearer {
+}
+/**
+ * <p>Returns information about a resource policy.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { NetworkManagerClient, GetResourcePolicyCommand } from "@aws-sdk/client-networkmanager"; // ES Modules import
+ * // const { NetworkManagerClient, GetResourcePolicyCommand } = require("@aws-sdk/client-networkmanager"); // CommonJS import
+ * const client = new NetworkManagerClient(config);
+ * const command = new GetResourcePolicyCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetResourcePolicyCommandInput} for command's `input` shape.
+ * @see {@link GetResourcePolicyCommandOutput} for command's `response` shape.
+ * @see {@link NetworkManagerClientResolvedConfig | config} for NetworkManagerClient's `config` shape.
+ *
+ */
+export declare class GetResourcePolicyCommand extends $Command<GetResourcePolicyCommandInput, GetResourcePolicyCommandOutput, NetworkManagerClientResolvedConfig> {
+    readonly input: GetResourcePolicyCommandInput;
+    constructor(input: GetResourcePolicyCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: NetworkManagerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetResourcePolicyCommandInput, GetResourcePolicyCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetSiteToSiteVpnAttachmentCommand.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 { GetSiteToSiteVpnAttachmentRequest, GetSiteToSiteVpnAttachmentResponse } from "../models/models_0";
+import { NetworkManagerClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../NetworkManagerClient";
+export interface GetSiteToSiteVpnAttachmentCommandInput extends GetSiteToSiteVpnAttachmentRequest {
+}
+export interface GetSiteToSiteVpnAttachmentCommandOutput extends GetSiteToSiteVpnAttachmentResponse, __MetadataBearer {
+}
+/**
+ * <p>Returns information about a site-to-site VPN attachment.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { NetworkManagerClient, GetSiteToSiteVpnAttachmentCommand } from "@aws-sdk/client-networkmanager"; // ES Modules import
+ * // const { NetworkManagerClient, GetSiteToSiteVpnAttachmentCommand } = require("@aws-sdk/client-networkmanager"); // CommonJS import
+ * const client = new NetworkManagerClient(config);
+ * const command = new GetSiteToSiteVpnAttachmentCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetSiteToSiteVpnAttachmentCommandInput} for command's `input` shape.
+ * @see {@link GetSiteToSiteVpnAttachmentCommandOutput} for command's `response` shape.
+ * @see {@link NetworkManagerClientResolvedConfig | config} for NetworkManagerClient's `config` shape.
+ *
+ */
+export declare class GetSiteToSiteVpnAttachmentCommand extends $Command<GetSiteToSiteVpnAttachmentCommandInput, GetSiteToSiteVpnAttachmentCommandOutput, NetworkManagerClientResolvedConfig> {
+    readonly input: GetSiteToSiteVpnAttachmentCommandInput;
+    constructor(input: GetSiteToSiteVpnAttachmentCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: NetworkManagerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetSiteToSiteVpnAttachmentCommandInput, GetSiteToSiteVpnAttachmentCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetVpcAttachmentCommand.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 { GetVpcAttachmentRequest, GetVpcAttachmentResponse } from "../models/models_0";
+import { NetworkManagerClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../NetworkManagerClient";
+export interface GetVpcAttachmentCommandInput extends GetVpcAttachmentRequest {
+}
+export interface GetVpcAttachmentCommandOutput extends GetVpcAttachmentResponse, __MetadataBearer {
+}
+/**
+ * <p>Returns information about a VPC attachment.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { NetworkManagerClient, GetVpcAttachmentCommand } from "@aws-sdk/client-networkmanager"; // ES Modules import
+ * // const { NetworkManagerClient, GetVpcAttachmentCommand } = require("@aws-sdk/client-networkmanager"); // CommonJS import
+ * const client = new NetworkManagerClient(config);
+ * const command = new GetVpcAttachmentCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetVpcAttachmentCommandInput} for command's `input` shape.
+ * @see {@link GetVpcAttachmentCommandOutput} for command's `response` shape.
+ * @see {@link NetworkManagerClientResolvedConfig | config} for NetworkManagerClient's `config` shape.
+ *
+ */
+export declare class GetVpcAttachmentCommand extends $Command<GetVpcAttachmentCommandInput, GetVpcAttachmentCommandOutput, NetworkManagerClientResolvedConfig> {
+    readonly input: GetVpcAttachmentCommandInput;
+    constructor(input: GetVpcAttachmentCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: NetworkManagerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetVpcAttachmentCommandInput, GetVpcAttachmentCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/ListAttachmentsCommand.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 { ListAttachmentsRequest, ListAttachmentsResponse } from "../models/models_0";
+import { NetworkManagerClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../NetworkManagerClient";
+export interface ListAttachmentsCommandInput extends ListAttachmentsRequest {
+}
+export interface ListAttachmentsCommandOutput extends ListAttachmentsResponse, __MetadataBearer {
+}
+/**
+ * <p>Returns a list of core network attachments.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { NetworkManagerClient, ListAttachmentsCommand } from "@aws-sdk/client-networkmanager"; // ES Modules import
+ * // const { NetworkManagerClient, ListAttachmentsCommand } = require("@aws-sdk/client-networkmanager"); // CommonJS import
+ * const client = new NetworkManagerClient(config);
+ * const command = new ListAttachmentsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListAttachmentsCommandInput} for command's `input` shape.
+ * @see {@link ListAttachmentsCommandOutput} for command's `response` shape.
+ * @see {@link NetworkManagerClientResolvedConfig | config} for NetworkManagerClient's `config` shape.
+ *
+ */
+export declare class ListAttachmentsCommand extends $Command<ListAttachmentsCommandInput, ListAttachmentsCommandOutput, NetworkManagerClientResolvedConfig> {
+    readonly input: ListAttachmentsCommandInput;
+    constructor(input: ListAttachmentsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: NetworkManagerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListAttachmentsCommandInput, ListAttachmentsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/ListConnectPeersCommand.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 { ListConnectPeersRequest, ListConnectPeersResponse } from "../models/models_0";
+import { NetworkManagerClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../NetworkManagerClient";
+export interface ListConnectPeersCommandInput extends ListConnectPeersRequest {
+}
+export interface ListConnectPeersCommandOutput extends ListConnectPeersResponse, __MetadataBearer {
+}
+/**
+ * <p>Returns a list of core network Connect peers.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { NetworkManagerClient, ListConnectPeersCommand } from "@aws-sdk/client-networkmanager"; // ES Modules import
+ * // const { NetworkManagerClient, ListConnectPeersCommand } = require("@aws-sdk/client-networkmanager"); // CommonJS import
+ * const client = new NetworkManagerClient(config);
+ * const command = new ListConnectPeersCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListConnectPeersCommandInput} for command's `input` shape.
+ * @see {@link ListConnectPeersCommandOutput} for command's `response` shape.
+ * @see {@link NetworkManagerClientResolvedConfig | config} for NetworkManagerClient's `config` shape.
+ *
+ */
+export declare class ListConnectPeersCommand extends $Command<ListConnectPeersCommandInput, ListConnectPeersCommandOutput, NetworkManagerClientResolvedConfig> {
+    readonly input: ListConnectPeersCommandInput;
+    constructor(input: ListConnectPeersCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: NetworkManagerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListConnectPeersCommandInput, ListConnectPeersCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/ListCoreNetworkPolicyVersionsCommand.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 { ListCoreNetworkPolicyVersionsRequest, ListCoreNetworkPolicyVersionsResponse } from "../models/models_0";
+import { NetworkManagerClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../NetworkManagerClient";
+export interface ListCoreNetworkPolicyVersionsCommandInput extends ListCoreNetworkPolicyVersionsRequest {
+}
+export interface ListCoreNetworkPolicyVersionsCommandOutput extends ListCoreNetworkPolicyVersionsResponse, __MetadataBearer {
+}
+/**
+ * <p>Returns a list of core network policy versions.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { NetworkManagerClient, ListCoreNetworkPolicyVersionsCommand } from "@aws-sdk/client-networkmanager"; // ES Modules import
+ * // const { NetworkManagerClient, ListCoreNetworkPolicyVersionsCommand } = require("@aws-sdk/client-networkmanager"); // CommonJS import
+ * const client = new NetworkManagerClient(config);
+ * const command = new ListCoreNetworkPolicyVersionsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListCoreNetworkPolicyVersionsCommandInput} for command's `input` shape.
+ * @see {@link ListCoreNetworkPolicyVersionsCommandOutput} for command's `response` shape.
+ * @see {@link NetworkManagerClientResolvedConfig | config} for NetworkManagerClient's `config` shape.
+ *
+ */
+export declare class ListCoreNetworkPolicyVersionsCommand extends $Command<ListCoreNetworkPolicyVersionsCommandInput, ListCoreNetworkPolicyVersionsCommandOutput, NetworkManagerClientResolvedConfig> {
+    readonly input: ListCoreNetworkPolicyVersionsCommandInput;
+    constructor(input: ListCoreNetworkPolicyVersionsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: NetworkManagerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListCoreNetworkPolicyVersionsCommandInput, ListCoreNetworkPolicyVersionsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/ListCoreNetworksCommand.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 { ListCoreNetworksRequest, ListCoreNetworksResponse } from "../models/models_0";
+import { NetworkManagerClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../NetworkManagerClient";
+export interface ListCoreNetworksCommandInput extends ListCoreNetworksRequest {
+}
+export interface ListCoreNetworksCommandOutput extends ListCoreNetworksResponse, __MetadataBearer {
+}
+/**
+ * <p>Returns a list of owned and shared core networks.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { NetworkManagerClient, ListCoreNetworksCommand } from "@aws-sdk/client-networkmanager"; // ES Modules import
+ * // const { NetworkManagerClient, ListCoreNetworksCommand } = require("@aws-sdk/client-networkmanager"); // CommonJS import
+ * const client = new NetworkManagerClient(config);
+ * const command = new ListCoreNetworksCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListCoreNetworksCommandInput} for command's `input` shape.
+ * @see {@link ListCoreNetworksCommandOutput} for command's `response` shape.
+ * @see {@link NetworkManagerClientResolvedConfig | config} for NetworkManagerClient's `config` shape.
+ *
+ */
+export declare class ListCoreNetworksCommand extends $Command<ListCoreNetworksCommandInput, ListCoreNetworksCommandOutput, NetworkManagerClientResolvedConfig> {
+    readonly input: ListCoreNetworksCommandInput;
+    constructor(input: ListCoreNetworksCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: NetworkManagerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListCoreNetworksCommandInput, ListCoreNetworksCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/PutCoreNetworkPolicyCommand.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 { PutCoreNetworkPolicyRequest, PutCoreNetworkPolicyResponse } from "../models/models_0";
+import { NetworkManagerClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../NetworkManagerClient";
+export interface PutCoreNetworkPolicyCommandInput extends PutCoreNetworkPolicyRequest {
+}
+export interface PutCoreNetworkPolicyCommandOutput extends PutCoreNetworkPolicyResponse, __MetadataBearer {
+}
+/**
+ * <p>Creates a new, immutable version of a core network policy. A subsequent change set is created showing the differences between the LIVE policy and the submitted policy.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { NetworkManagerClient, PutCoreNetworkPolicyCommand } from "@aws-sdk/client-networkmanager"; // ES Modules import
+ * // const { NetworkManagerClient, PutCoreNetworkPolicyCommand } = require("@aws-sdk/client-networkmanager"); // CommonJS import
+ * const client = new NetworkManagerClient(config);
+ * const command = new PutCoreNetworkPolicyCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link PutCoreNetworkPolicyCommandInput} for command's `input` shape.
+ * @see {@link PutCoreNetworkPolicyCommandOutput} for command's `response` shape.
+ * @see {@link NetworkManagerClientResolvedConfig | config} for NetworkManagerClient's `config` shape.
+ *
+ */
+export declare class PutCoreNetworkPolicyCommand extends $Command<PutCoreNetworkPolicyCommandInput, PutCoreNetworkPolicyCommandOutput, NetworkManagerClientResolvedConfig> {
+    readonly input: PutCoreNetworkPolicyCommandInput;
+    constructor(input: PutCoreNetworkPolicyCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: NetworkManagerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutCoreNetworkPolicyCommandInput, PutCoreNetworkPolicyCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/PutResourcePolicyCommand.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 { PutResourcePolicyRequest, PutResourcePolicyResponse } from "../models/models_0";
+import { NetworkManagerClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../NetworkManagerClient";
+export interface PutResourcePolicyCommandInput extends PutResourcePolicyRequest {
+}
+export interface PutResourcePolicyCommandOutput extends PutResourcePolicyResponse, __MetadataBearer {
+}
+/**
+ * <p>Creates or updates a resource policy.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { NetworkManagerClient, PutResourcePolicyCommand } from "@aws-sdk/client-networkmanager"; // ES Modules import
+ * // const { NetworkManagerClient, PutResourcePolicyCommand } = require("@aws-sdk/client-networkmanager"); // CommonJS import
+ * const client = new NetworkManagerClient(config);
+ * const command = new PutResourcePolicyCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link PutResourcePolicyCommandInput} for command's `input` shape.
+ * @see {@link PutResourcePolicyCommandOutput} for command's `response` shape.
+ * @see {@link NetworkManagerClientResolvedConfig | config} for NetworkManagerClient's `config` shape.
+ *
+ */
+export declare class PutResourcePolicyCommand extends $Command<PutResourcePolicyCommandInput, PutResourcePolicyCommandOutput, NetworkManagerClientResolvedConfig> {
+    readonly input: PutResourcePolicyCommandInput;
+    constructor(input: PutResourcePolicyCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: NetworkManagerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutResourcePolicyCommandInput, PutResourcePolicyCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/RejectAttachmentCommand.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 { RejectAttachmentRequest, RejectAttachmentResponse } from "../models/models_0";
+import { NetworkManagerClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../NetworkManagerClient";
+export interface RejectAttachmentCommandInput extends RejectAttachmentRequest {
+}
+export interface RejectAttachmentCommandOutput extends RejectAttachmentResponse, __MetadataBearer {
+}
+/**
+ * <p>Rejects a core network attachment request.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { NetworkManagerClient, RejectAttachmentCommand } from "@aws-sdk/client-networkmanager"; // ES Modules import
+ * // const { NetworkManagerClient, RejectAttachmentCommand } = require("@aws-sdk/client-networkmanager"); // CommonJS import
+ * const client = new NetworkManagerClient(config);
+ * const command = new RejectAttachmentCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link RejectAttachmentCommandInput} for command's `input` shape.
+ * @see {@link RejectAttachmentCommandOutput} for command's `response` shape.
+ * @see {@link NetworkManagerClientResolvedConfig | config} for NetworkManagerClient's `config` shape.
+ *
+ */
+export declare class RejectAttachmentCommand extends $Command<RejectAttachmentCommandInput, RejectAttachmentCommandOutput, NetworkManagerClientResolvedConfig> {
+    readonly input: RejectAttachmentCommandInput;
+    constructor(input: RejectAttachmentCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: NetworkManagerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<RejectAttachmentCommandInput, RejectAttachmentCommandOutput>;
+    private serialize;
+    private deserialize;
+}