@aws-sdk/client-vpc-lattice 3.303.0

package/dist-es/runtimeConfig.browser.js

@@ -0,0 +1,34 @@
+import packageInfo from "../package.json";
+import { Sha256 } from "@aws-crypto/sha256-browser";
+import { DEFAULT_USE_DUALSTACK_ENDPOINT, DEFAULT_USE_FIPS_ENDPOINT } from "@aws-sdk/config-resolver";
+import { FetchHttpHandler as RequestHandler, streamCollector } from "@aws-sdk/fetch-http-handler";
+import { invalidProvider } from "@aws-sdk/invalid-dependency";
+import { calculateBodyLength } from "@aws-sdk/util-body-length-browser";
+import { DEFAULT_MAX_ATTEMPTS, DEFAULT_RETRY_MODE } from "@aws-sdk/util-retry";
+import { defaultUserAgent } from "@aws-sdk/util-user-agent-browser";
+import { getRuntimeConfig as getSharedRuntimeConfig } from "./runtimeConfig.shared";
+import { loadConfigsForDefaultMode } from "@aws-sdk/smithy-client";
+import { resolveDefaultsModeConfig } from "@aws-sdk/util-defaults-mode-browser";
+export const getRuntimeConfig = (config) => {
+    const defaultsMode = resolveDefaultsModeConfig(config);
+    const defaultConfigProvider = () => defaultsMode().then(loadConfigsForDefaultMode);
+    const clientSharedValues = getSharedRuntimeConfig(config);
+    return {
+        ...clientSharedValues,
+        ...config,
+        runtime: "browser",
+        defaultsMode,
+        bodyLengthChecker: config?.bodyLengthChecker ?? calculateBodyLength,
+        credentialDefaultProvider: config?.credentialDefaultProvider ?? ((_) => () => Promise.reject(new Error("Credential is missing"))),
+        defaultUserAgentProvider: config?.defaultUserAgentProvider ??
+            defaultUserAgent({ serviceId: clientSharedValues.serviceId, clientVersion: packageInfo.version }),
+        maxAttempts: config?.maxAttempts ?? DEFAULT_MAX_ATTEMPTS,
+        region: config?.region ?? invalidProvider("Region is missing"),
+        requestHandler: config?.requestHandler ?? new RequestHandler(defaultConfigProvider),
+        retryMode: config?.retryMode ?? (async () => (await defaultConfigProvider()).retryMode || DEFAULT_RETRY_MODE),
+        sha256: config?.sha256 ?? Sha256,
+        streamCollector: config?.streamCollector ?? streamCollector,
+        useDualstackEndpoint: config?.useDualstackEndpoint ?? (() => Promise.resolve(DEFAULT_USE_DUALSTACK_ENDPOINT)),
+        useFipsEndpoint: config?.useFipsEndpoint ?? (() => Promise.resolve(DEFAULT_USE_FIPS_ENDPOINT)),
+    };
+};

package/dist-es/runtimeConfig.js

@@ -0,0 +1,43 @@
+import packageInfo from "../package.json";
+import { decorateDefaultCredentialProvider } from "@aws-sdk/client-sts";
+import { NODE_REGION_CONFIG_FILE_OPTIONS, NODE_REGION_CONFIG_OPTIONS, NODE_USE_DUALSTACK_ENDPOINT_CONFIG_OPTIONS, NODE_USE_FIPS_ENDPOINT_CONFIG_OPTIONS, } from "@aws-sdk/config-resolver";
+import { defaultProvider as credentialDefaultProvider } from "@aws-sdk/credential-provider-node";
+import { Hash } from "@aws-sdk/hash-node";
+import { NODE_MAX_ATTEMPT_CONFIG_OPTIONS, NODE_RETRY_MODE_CONFIG_OPTIONS } from "@aws-sdk/middleware-retry";
+import { loadConfig as loadNodeConfig } from "@aws-sdk/node-config-provider";
+import { NodeHttpHandler as RequestHandler, streamCollector } from "@aws-sdk/node-http-handler";
+import { calculateBodyLength } from "@aws-sdk/util-body-length-node";
+import { DEFAULT_RETRY_MODE } from "@aws-sdk/util-retry";
+import { defaultUserAgent } from "@aws-sdk/util-user-agent-node";
+import { getRuntimeConfig as getSharedRuntimeConfig } from "./runtimeConfig.shared";
+import { loadConfigsForDefaultMode } from "@aws-sdk/smithy-client";
+import { resolveDefaultsModeConfig } from "@aws-sdk/util-defaults-mode-node";
+import { emitWarningIfUnsupportedVersion } from "@aws-sdk/smithy-client";
+export const getRuntimeConfig = (config) => {
+    emitWarningIfUnsupportedVersion(process.version);
+    const defaultsMode = resolveDefaultsModeConfig(config);
+    const defaultConfigProvider = () => defaultsMode().then(loadConfigsForDefaultMode);
+    const clientSharedValues = getSharedRuntimeConfig(config);
+    return {
+        ...clientSharedValues,
+        ...config,
+        runtime: "node",
+        defaultsMode,
+        bodyLengthChecker: config?.bodyLengthChecker ?? calculateBodyLength,
+        credentialDefaultProvider: config?.credentialDefaultProvider ?? decorateDefaultCredentialProvider(credentialDefaultProvider),
+        defaultUserAgentProvider: config?.defaultUserAgentProvider ??
+            defaultUserAgent({ serviceId: clientSharedValues.serviceId, clientVersion: packageInfo.version }),
+        maxAttempts: config?.maxAttempts ?? loadNodeConfig(NODE_MAX_ATTEMPT_CONFIG_OPTIONS),
+        region: config?.region ?? loadNodeConfig(NODE_REGION_CONFIG_OPTIONS, NODE_REGION_CONFIG_FILE_OPTIONS),
+        requestHandler: config?.requestHandler ?? new RequestHandler(defaultConfigProvider),
+        retryMode: config?.retryMode ??
+            loadNodeConfig({
+                ...NODE_RETRY_MODE_CONFIG_OPTIONS,
+                default: async () => (await defaultConfigProvider()).retryMode || DEFAULT_RETRY_MODE,
+            }),
+        sha256: config?.sha256 ?? Hash.bind(null, "sha256"),
+        streamCollector: config?.streamCollector ?? streamCollector,
+        useDualstackEndpoint: config?.useDualstackEndpoint ?? loadNodeConfig(NODE_USE_DUALSTACK_ENDPOINT_CONFIG_OPTIONS),
+        useFipsEndpoint: config?.useFipsEndpoint ?? loadNodeConfig(NODE_USE_FIPS_ENDPOINT_CONFIG_OPTIONS),
+    };
+};

package/dist-es/runtimeConfig.native.js

@@ -0,0 +1,11 @@
+import { Sha256 } from "@aws-crypto/sha256-js";
+import { getRuntimeConfig as getBrowserRuntimeConfig } from "./runtimeConfig.browser";
+export const getRuntimeConfig = (config) => {
+    const browserDefaults = getBrowserRuntimeConfig(config);
+    return {
+        ...browserDefaults,
+        ...config,
+        runtime: "react-native",
+        sha256: config?.sha256 ?? Sha256,
+    };
+};

package/dist-es/runtimeConfig.shared.js

@@ -0,0 +1,17 @@
+import { NoOpLogger } from "@aws-sdk/smithy-client";
+import { parseUrl } from "@aws-sdk/url-parser";
+import { fromBase64, toBase64 } from "@aws-sdk/util-base64";
+import { fromUtf8, toUtf8 } from "@aws-sdk/util-utf8";
+import { defaultEndpointResolver } from "./endpoint/endpointResolver";
+export const getRuntimeConfig = (config) => ({
+    apiVersion: "2022-11-30",
+    base64Decoder: config?.base64Decoder ?? fromBase64,
+    base64Encoder: config?.base64Encoder ?? toBase64,
+    disableHostPrefix: config?.disableHostPrefix ?? false,
+    endpointProvider: config?.endpointProvider ?? defaultEndpointResolver,
+    logger: config?.logger ?? new NoOpLogger(),
+    serviceId: config?.serviceId ?? "VPC Lattice",
+    urlParser: config?.urlParser ?? parseUrl,
+    utf8Decoder: config?.utf8Decoder ?? fromUtf8,
+    utf8Encoder: config?.utf8Encoder ?? toUtf8,
+});

package/dist-types/VPCLattice.d.ts

@@ -0,0 +1,506 @@
+import { HttpHandlerOptions as __HttpHandlerOptions } from "@aws-sdk/types";
+import { BatchUpdateRuleCommandInput, BatchUpdateRuleCommandOutput } from "./commands/BatchUpdateRuleCommand";
+import { CreateAccessLogSubscriptionCommandInput, CreateAccessLogSubscriptionCommandOutput } from "./commands/CreateAccessLogSubscriptionCommand";
+import { CreateListenerCommandInput, CreateListenerCommandOutput } from "./commands/CreateListenerCommand";
+import { CreateRuleCommandInput, CreateRuleCommandOutput } from "./commands/CreateRuleCommand";
+import { CreateServiceCommandInput, CreateServiceCommandOutput } from "./commands/CreateServiceCommand";
+import { CreateServiceNetworkCommandInput, CreateServiceNetworkCommandOutput } from "./commands/CreateServiceNetworkCommand";
+import { CreateServiceNetworkServiceAssociationCommandInput, CreateServiceNetworkServiceAssociationCommandOutput } from "./commands/CreateServiceNetworkServiceAssociationCommand";
+import { CreateServiceNetworkVpcAssociationCommandInput, CreateServiceNetworkVpcAssociationCommandOutput } from "./commands/CreateServiceNetworkVpcAssociationCommand";
+import { CreateTargetGroupCommandInput, CreateTargetGroupCommandOutput } from "./commands/CreateTargetGroupCommand";
+import { DeleteAccessLogSubscriptionCommandInput, DeleteAccessLogSubscriptionCommandOutput } from "./commands/DeleteAccessLogSubscriptionCommand";
+import { DeleteAuthPolicyCommandInput, DeleteAuthPolicyCommandOutput } from "./commands/DeleteAuthPolicyCommand";
+import { DeleteListenerCommandInput, DeleteListenerCommandOutput } from "./commands/DeleteListenerCommand";
+import { DeleteResourcePolicyCommandInput, DeleteResourcePolicyCommandOutput } from "./commands/DeleteResourcePolicyCommand";
+import { DeleteRuleCommandInput, DeleteRuleCommandOutput } from "./commands/DeleteRuleCommand";
+import { DeleteServiceCommandInput, DeleteServiceCommandOutput } from "./commands/DeleteServiceCommand";
+import { DeleteServiceNetworkCommandInput, DeleteServiceNetworkCommandOutput } from "./commands/DeleteServiceNetworkCommand";
+import { DeleteServiceNetworkServiceAssociationCommandInput, DeleteServiceNetworkServiceAssociationCommandOutput } from "./commands/DeleteServiceNetworkServiceAssociationCommand";
+import { DeleteServiceNetworkVpcAssociationCommandInput, DeleteServiceNetworkVpcAssociationCommandOutput } from "./commands/DeleteServiceNetworkVpcAssociationCommand";
+import { DeleteTargetGroupCommandInput, DeleteTargetGroupCommandOutput } from "./commands/DeleteTargetGroupCommand";
+import { DeregisterTargetsCommandInput, DeregisterTargetsCommandOutput } from "./commands/DeregisterTargetsCommand";
+import { GetAccessLogSubscriptionCommandInput, GetAccessLogSubscriptionCommandOutput } from "./commands/GetAccessLogSubscriptionCommand";
+import { GetAuthPolicyCommandInput, GetAuthPolicyCommandOutput } from "./commands/GetAuthPolicyCommand";
+import { GetListenerCommandInput, GetListenerCommandOutput } from "./commands/GetListenerCommand";
+import { GetResourcePolicyCommandInput, GetResourcePolicyCommandOutput } from "./commands/GetResourcePolicyCommand";
+import { GetRuleCommandInput, GetRuleCommandOutput } from "./commands/GetRuleCommand";
+import { GetServiceCommandInput, GetServiceCommandOutput } from "./commands/GetServiceCommand";
+import { GetServiceNetworkCommandInput, GetServiceNetworkCommandOutput } from "./commands/GetServiceNetworkCommand";
+import { GetServiceNetworkServiceAssociationCommandInput, GetServiceNetworkServiceAssociationCommandOutput } from "./commands/GetServiceNetworkServiceAssociationCommand";
+import { GetServiceNetworkVpcAssociationCommandInput, GetServiceNetworkVpcAssociationCommandOutput } from "./commands/GetServiceNetworkVpcAssociationCommand";
+import { GetTargetGroupCommandInput, GetTargetGroupCommandOutput } from "./commands/GetTargetGroupCommand";
+import { ListAccessLogSubscriptionsCommandInput, ListAccessLogSubscriptionsCommandOutput } from "./commands/ListAccessLogSubscriptionsCommand";
+import { ListListenersCommandInput, ListListenersCommandOutput } from "./commands/ListListenersCommand";
+import { ListRulesCommandInput, ListRulesCommandOutput } from "./commands/ListRulesCommand";
+import { ListServiceNetworksCommandInput, ListServiceNetworksCommandOutput } from "./commands/ListServiceNetworksCommand";
+import { ListServiceNetworkServiceAssociationsCommandInput, ListServiceNetworkServiceAssociationsCommandOutput } from "./commands/ListServiceNetworkServiceAssociationsCommand";
+import { ListServiceNetworkVpcAssociationsCommandInput, ListServiceNetworkVpcAssociationsCommandOutput } from "./commands/ListServiceNetworkVpcAssociationsCommand";
+import { ListServicesCommandInput, ListServicesCommandOutput } from "./commands/ListServicesCommand";
+import { ListTagsForResourceCommandInput, ListTagsForResourceCommandOutput } from "./commands/ListTagsForResourceCommand";
+import { ListTargetGroupsCommandInput, ListTargetGroupsCommandOutput } from "./commands/ListTargetGroupsCommand";
+import { ListTargetsCommandInput, ListTargetsCommandOutput } from "./commands/ListTargetsCommand";
+import { PutAuthPolicyCommandInput, PutAuthPolicyCommandOutput } from "./commands/PutAuthPolicyCommand";
+import { PutResourcePolicyCommandInput, PutResourcePolicyCommandOutput } from "./commands/PutResourcePolicyCommand";
+import { RegisterTargetsCommandInput, RegisterTargetsCommandOutput } from "./commands/RegisterTargetsCommand";
+import { TagResourceCommandInput, TagResourceCommandOutput } from "./commands/TagResourceCommand";
+import { UntagResourceCommandInput, UntagResourceCommandOutput } from "./commands/UntagResourceCommand";
+import { UpdateAccessLogSubscriptionCommandInput, UpdateAccessLogSubscriptionCommandOutput } from "./commands/UpdateAccessLogSubscriptionCommand";
+import { UpdateListenerCommandInput, UpdateListenerCommandOutput } from "./commands/UpdateListenerCommand";
+import { UpdateRuleCommandInput, UpdateRuleCommandOutput } from "./commands/UpdateRuleCommand";
+import { UpdateServiceCommandInput, UpdateServiceCommandOutput } from "./commands/UpdateServiceCommand";
+import { UpdateServiceNetworkCommandInput, UpdateServiceNetworkCommandOutput } from "./commands/UpdateServiceNetworkCommand";
+import { UpdateServiceNetworkVpcAssociationCommandInput, UpdateServiceNetworkVpcAssociationCommandOutput } from "./commands/UpdateServiceNetworkVpcAssociationCommand";
+import { UpdateTargetGroupCommandInput, UpdateTargetGroupCommandOutput } from "./commands/UpdateTargetGroupCommand";
+import { VPCLatticeClient } from "./VPCLatticeClient";
+/**
+ * @public
+ * <p>Amazon VPC Lattice is a fully managed application networking service that you use to connect, secure,
+ *    and monitor all of your services across multiple accounts and virtual private clouds (VPCs).
+ *    Amazon VPC Lattice interconnects your microservices and legacy services within a logical boundary, so that
+ *    you can discover and manage them more efficiently. For more information, see the <a href="https://docs.aws.amazon.com/vpc-lattice/latest/ug/">Amazon VPC Lattice User Guide</a>
+ *          </p>
+ */
+export declare class VPCLattice extends VPCLatticeClient {
+    /**
+     * @public
+     * <p>Updates the listener rules in a batch. You can use this operation to change the priority of
+     *    listener rules. This can be useful when bulk updating or swapping rule priority. </p>
+     */
+    batchUpdateRule(args: BatchUpdateRuleCommandInput, options?: __HttpHandlerOptions): Promise<BatchUpdateRuleCommandOutput>;
+    batchUpdateRule(args: BatchUpdateRuleCommandInput, cb: (err: any, data?: BatchUpdateRuleCommandOutput) => void): void;
+    batchUpdateRule(args: BatchUpdateRuleCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: BatchUpdateRuleCommandOutput) => void): void;
+    /**
+     * @public
+     * <p>Enables access logs to be sent to Amazon CloudWatch, Amazon S3, and Amazon Kinesis Data Firehose. The service network owner
+     *    can use the access logs to audit the services in the network. The service network owner will only
+     *    see access logs from clients and services that are associated with their service network. Access
+     *    log entries represent traffic originated from VPCs associated with that network. For more
+     *    information, see <a href="https://docs.aws.amazon.com/vpc-lattice/latest/ug/monitoring-access-logs.html">Access logs</a> in the
+     *     <i>Amazon VPC Lattice User Guide</i>.</p>
+     */
+    createAccessLogSubscription(args: CreateAccessLogSubscriptionCommandInput, options?: __HttpHandlerOptions): Promise<CreateAccessLogSubscriptionCommandOutput>;
+    createAccessLogSubscription(args: CreateAccessLogSubscriptionCommandInput, cb: (err: any, data?: CreateAccessLogSubscriptionCommandOutput) => void): void;
+    createAccessLogSubscription(args: CreateAccessLogSubscriptionCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: CreateAccessLogSubscriptionCommandOutput) => void): void;
+    /**
+     * @public
+     * <p>Creates a listener for a service. Before you start using your Amazon VPC Lattice service, you must
+     *    add one or more listeners. A listener is a process that checks for connection requests to your
+     *    services. For more information, see <a href="https://docs.aws.amazon.com/vpc-lattice/latest/ug/listeners.html">Listeners</a> in the
+     *    <i>Amazon VPC Lattice User Guide</i>.</p>
+     */
+    createListener(args: CreateListenerCommandInput, options?: __HttpHandlerOptions): Promise<CreateListenerCommandOutput>;
+    createListener(args: CreateListenerCommandInput, cb: (err: any, data?: CreateListenerCommandOutput) => void): void;
+    createListener(args: CreateListenerCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: CreateListenerCommandOutput) => void): void;
+    /**
+     * @public
+     * <p>Creates a listener rule. Each listener has a default rule for checking connection requests,
+     *    but you can define additional rules. Each rule consists of a priority, one or more actions, and
+     *    one or more conditions. For more information, see <a href="https://docs.aws.amazon.com/vpc-lattice/latest/ug/listeners.html#listener-rules">Listener rules</a> in the
+     *     <i>Amazon VPC Lattice User Guide</i>.</p>
+     */
+    createRule(args: CreateRuleCommandInput, options?: __HttpHandlerOptions): Promise<CreateRuleCommandOutput>;
+    createRule(args: CreateRuleCommandInput, cb: (err: any, data?: CreateRuleCommandOutput) => void): void;
+    createRule(args: CreateRuleCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: CreateRuleCommandOutput) => void): void;
+    /**
+     * @public
+     * <p>Creates a service. A service is any software application that can run on instances
+     *    containers, or serverless functions within an account or virtual private cloud (VPC).</p>
+     *          <p>For more information, see <a href="https://docs.aws.amazon.com/vpc-lattice/latest/ug/services.html">Services</a> in the
+     *    <i>Amazon VPC Lattice User Guide</i>.</p>
+     */
+    createService(args: CreateServiceCommandInput, options?: __HttpHandlerOptions): Promise<CreateServiceCommandOutput>;
+    createService(args: CreateServiceCommandInput, cb: (err: any, data?: CreateServiceCommandOutput) => void): void;
+    createService(args: CreateServiceCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: CreateServiceCommandOutput) => void): void;
+    /**
+     * @public
+     * <p>Creates a service network. A service network is a logical boundary for a collection of
+     *    services. You can associate services and VPCs with a service network.</p>
+     *          <p>For more information, see <a href="https://docs.aws.amazon.com/vpc-lattice/latest/ug/service-networks.html">Service networks</a> in the
+     *     <i>Amazon VPC Lattice User Guide</i>.</p>
+     */
+    createServiceNetwork(args: CreateServiceNetworkCommandInput, options?: __HttpHandlerOptions): Promise<CreateServiceNetworkCommandOutput>;
+    createServiceNetwork(args: CreateServiceNetworkCommandInput, cb: (err: any, data?: CreateServiceNetworkCommandOutput) => void): void;
+    createServiceNetwork(args: CreateServiceNetworkCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: CreateServiceNetworkCommandOutput) => void): void;
+    /**
+     * @public
+     * <p>Associates a service with a service network.</p>
+     *          <p>You can't use this operation if the service and service network are already associated or if
+     *    there is a disassociation or deletion in progress. If the association fails, you can retry the
+     *    operation by deleting the association and recreating it.</p>
+     *          <p>You cannot associate a service and service network that are shared with a caller. The caller
+     *    must own either the service or the service network.</p>
+     *          <p>As a result of this operation, the association is created in the service network account and
+     *    the association owner account.</p>
+     */
+    createServiceNetworkServiceAssociation(args: CreateServiceNetworkServiceAssociationCommandInput, options?: __HttpHandlerOptions): Promise<CreateServiceNetworkServiceAssociationCommandOutput>;
+    createServiceNetworkServiceAssociation(args: CreateServiceNetworkServiceAssociationCommandInput, cb: (err: any, data?: CreateServiceNetworkServiceAssociationCommandOutput) => void): void;
+    createServiceNetworkServiceAssociation(args: CreateServiceNetworkServiceAssociationCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: CreateServiceNetworkServiceAssociationCommandOutput) => void): void;
+    /**
+     * @public
+     * <p>Associates a VPC with a service network. When you associate a VPC with the service network,
+     *    it enables all the resources within that VPC to be clients and communicate with other services in
+     *    the service network. For more information, see <a href="https://docs.aws.amazon.com/vpc-lattice/latest/ug/service-network-associations.html#service-network-vpc-associations">Manage VPC associations</a> in the <i>Amazon VPC Lattice User Guide</i>.</p>
+     *          <p>You can't use this operation if there is a disassociation in progress. If the association
+     *    fails, retry by deleting the association and recreating it.</p>
+     *          <p>As a result of this operation, the association gets created in the service network account
+     *    and the VPC owner account.</p>
+     *          <p>Once a security group is added to the VPC association it cannot be removed. You can add or
+     *    update the security groups being used for the VPC association once a security group is attached.
+     *    To remove all security groups you must reassociate the VPC.</p>
+     */
+    createServiceNetworkVpcAssociation(args: CreateServiceNetworkVpcAssociationCommandInput, options?: __HttpHandlerOptions): Promise<CreateServiceNetworkVpcAssociationCommandOutput>;
+    createServiceNetworkVpcAssociation(args: CreateServiceNetworkVpcAssociationCommandInput, cb: (err: any, data?: CreateServiceNetworkVpcAssociationCommandOutput) => void): void;
+    createServiceNetworkVpcAssociation(args: CreateServiceNetworkVpcAssociationCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: CreateServiceNetworkVpcAssociationCommandOutput) => void): void;
+    /**
+     * @public
+     * <p>Creates a target group. A target group is a collection of targets, or compute resources,
+     *    that run your application or service. A target group can only be used by a single service.</p>
+     *          <p>For more information, see <a href="https://docs.aws.amazon.com/vpc-lattice/latest/ug/target-groups.html">Target groups</a> in the
+     *     <i>Amazon VPC Lattice User Guide</i>.</p>
+     */
+    createTargetGroup(args: CreateTargetGroupCommandInput, options?: __HttpHandlerOptions): Promise<CreateTargetGroupCommandOutput>;
+    createTargetGroup(args: CreateTargetGroupCommandInput, cb: (err: any, data?: CreateTargetGroupCommandOutput) => void): void;
+    createTargetGroup(args: CreateTargetGroupCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: CreateTargetGroupCommandOutput) => void): void;
+    /**
+     * @public
+     * <p>Deletes the specified access log subscription.</p>
+     */
+    deleteAccessLogSubscription(args: DeleteAccessLogSubscriptionCommandInput, options?: __HttpHandlerOptions): Promise<DeleteAccessLogSubscriptionCommandOutput>;
+    deleteAccessLogSubscription(args: DeleteAccessLogSubscriptionCommandInput, cb: (err: any, data?: DeleteAccessLogSubscriptionCommandOutput) => void): void;
+    deleteAccessLogSubscription(args: DeleteAccessLogSubscriptionCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DeleteAccessLogSubscriptionCommandOutput) => void): void;
+    /**
+     * @public
+     * <p>Deletes the specified auth policy. If an auth is set to <code>Amazon Web Services_IAM</code>
+     *    and the auth policy is deleted, all requests will be denied by default. If you are trying to
+     *    remove the auth policy completely, you must set the auth_type to <code>NONE</code>. If auth is
+     *    enabled on the resource, but no auth policy is set, all requests will be denied.</p>
+     */
+    deleteAuthPolicy(args: DeleteAuthPolicyCommandInput, options?: __HttpHandlerOptions): Promise<DeleteAuthPolicyCommandOutput>;
+    deleteAuthPolicy(args: DeleteAuthPolicyCommandInput, cb: (err: any, data?: DeleteAuthPolicyCommandOutput) => void): void;
+    deleteAuthPolicy(args: DeleteAuthPolicyCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DeleteAuthPolicyCommandOutput) => void): void;
+    /**
+     * @public
+     * <p>Deletes the specified listener.</p>
+     */
+    deleteListener(args: DeleteListenerCommandInput, options?: __HttpHandlerOptions): Promise<DeleteListenerCommandOutput>;
+    deleteListener(args: DeleteListenerCommandInput, cb: (err: any, data?: DeleteListenerCommandOutput) => void): void;
+    deleteListener(args: DeleteListenerCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DeleteListenerCommandOutput) => void): void;
+    /**
+     * @public
+     * <p>Deletes the specified resource policy.</p>
+     */
+    deleteResourcePolicy(args: DeleteResourcePolicyCommandInput, options?: __HttpHandlerOptions): Promise<DeleteResourcePolicyCommandOutput>;
+    deleteResourcePolicy(args: DeleteResourcePolicyCommandInput, cb: (err: any, data?: DeleteResourcePolicyCommandOutput) => void): void;
+    deleteResourcePolicy(args: DeleteResourcePolicyCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DeleteResourcePolicyCommandOutput) => void): void;
+    /**
+     * @public
+     * <p>Deletes a listener rule. Each listener has a default rule for checking connection requests,
+     *    but you can define additional rules. Each rule consists of a priority, one or more actions, and
+     *    one or more conditions. You can delete additional listener rules, but you cannot delete the
+     *    default rule.</p>
+     *          <p>For more information, see <a href="https://docs.aws.amazon.com/vpc-lattice/latest/ug/listeners.html#listener-rules">Listener rules</a> in the
+     *     <i>Amazon VPC Lattice User Guide</i>.</p>
+     */
+    deleteRule(args: DeleteRuleCommandInput, options?: __HttpHandlerOptions): Promise<DeleteRuleCommandOutput>;
+    deleteRule(args: DeleteRuleCommandInput, cb: (err: any, data?: DeleteRuleCommandOutput) => void): void;
+    deleteRule(args: DeleteRuleCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DeleteRuleCommandOutput) => void): void;
+    /**
+     * @public
+     * <p>Deletes a service. A service can't be deleted if it's associated with a service network. If
+     *    you delete a service, all resources related to the service, such as the resource policy, auth
+     *    policy, listeners, listener rules, and access log subscriptions, are also deleted. For more
+     *    information, see <a href="https://docs.aws.amazon.com/vpc-lattice/latest/ug/services.html#delete-service">Delete a service</a> in the
+     *     <i>Amazon VPC Lattice User Guide</i>.</p>
+     */
+    deleteService(args: DeleteServiceCommandInput, options?: __HttpHandlerOptions): Promise<DeleteServiceCommandOutput>;
+    deleteService(args: DeleteServiceCommandInput, cb: (err: any, data?: DeleteServiceCommandOutput) => void): void;
+    deleteService(args: DeleteServiceCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DeleteServiceCommandOutput) => void): void;
+    /**
+     * @public
+     * <p>Deletes a service network. You can only delete the service network if there is no service or
+     *    VPC associated with it. If you delete a service network, all resources related to the service
+     *    network, such as the resource policy, auth policy, and access log subscriptions, are also
+     *    deleted. For more information, see <a href="https://docs.aws.amazon.com/vpc-lattice/latest/ug/service-networks.html#delete-service-network">Delete a service
+     *     network</a> in the <i>Amazon VPC Lattice User Guide</i>.</p>
+     */
+    deleteServiceNetwork(args: DeleteServiceNetworkCommandInput, options?: __HttpHandlerOptions): Promise<DeleteServiceNetworkCommandOutput>;
+    deleteServiceNetwork(args: DeleteServiceNetworkCommandInput, cb: (err: any, data?: DeleteServiceNetworkCommandOutput) => void): void;
+    deleteServiceNetwork(args: DeleteServiceNetworkCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DeleteServiceNetworkCommandOutput) => void): void;
+    /**
+     * @public
+     * <p>Deletes the association between a specified service and the specific service network. This
+     *    request will fail if an association is still in progress.</p>
+     */
+    deleteServiceNetworkServiceAssociation(args: DeleteServiceNetworkServiceAssociationCommandInput, options?: __HttpHandlerOptions): Promise<DeleteServiceNetworkServiceAssociationCommandOutput>;
+    deleteServiceNetworkServiceAssociation(args: DeleteServiceNetworkServiceAssociationCommandInput, cb: (err: any, data?: DeleteServiceNetworkServiceAssociationCommandOutput) => void): void;
+    deleteServiceNetworkServiceAssociation(args: DeleteServiceNetworkServiceAssociationCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DeleteServiceNetworkServiceAssociationCommandOutput) => void): void;
+    /**
+     * @public
+     * <p>Disassociates the VPC from the service network. You can't disassociate the VPC if there is a
+     *    create or update association in progress.</p>
+     */
+    deleteServiceNetworkVpcAssociation(args: DeleteServiceNetworkVpcAssociationCommandInput, options?: __HttpHandlerOptions): Promise<DeleteServiceNetworkVpcAssociationCommandOutput>;
+    deleteServiceNetworkVpcAssociation(args: DeleteServiceNetworkVpcAssociationCommandInput, cb: (err: any, data?: DeleteServiceNetworkVpcAssociationCommandOutput) => void): void;
+    deleteServiceNetworkVpcAssociation(args: DeleteServiceNetworkVpcAssociationCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DeleteServiceNetworkVpcAssociationCommandOutput) => void): void;
+    /**
+     * @public
+     * <p>Deletes a target group. You can't delete a target group if it is used in a listener rule or
+     *    if the target group creation is in progress.</p>
+     */
+    deleteTargetGroup(args: DeleteTargetGroupCommandInput, options?: __HttpHandlerOptions): Promise<DeleteTargetGroupCommandOutput>;
+    deleteTargetGroup(args: DeleteTargetGroupCommandInput, cb: (err: any, data?: DeleteTargetGroupCommandOutput) => void): void;
+    deleteTargetGroup(args: DeleteTargetGroupCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DeleteTargetGroupCommandOutput) => void): void;
+    /**
+     * @public
+     * <p>Deregisters the specified targets from the specified target group.</p>
+     */
+    deregisterTargets(args: DeregisterTargetsCommandInput, options?: __HttpHandlerOptions): Promise<DeregisterTargetsCommandOutput>;
+    deregisterTargets(args: DeregisterTargetsCommandInput, cb: (err: any, data?: DeregisterTargetsCommandOutput) => void): void;
+    deregisterTargets(args: DeregisterTargetsCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DeregisterTargetsCommandOutput) => void): void;
+    /**
+     * @public
+     * <p>Retrieves information about the specified access log subscription.</p>
+     */
+    getAccessLogSubscription(args: GetAccessLogSubscriptionCommandInput, options?: __HttpHandlerOptions): Promise<GetAccessLogSubscriptionCommandOutput>;
+    getAccessLogSubscription(args: GetAccessLogSubscriptionCommandInput, cb: (err: any, data?: GetAccessLogSubscriptionCommandOutput) => void): void;
+    getAccessLogSubscription(args: GetAccessLogSubscriptionCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: GetAccessLogSubscriptionCommandOutput) => void): void;
+    /**
+     * @public
+     * <p>Retrieves information about the auth policy for the specified service or service
+     *    network.</p>
+     */
+    getAuthPolicy(args: GetAuthPolicyCommandInput, options?: __HttpHandlerOptions): Promise<GetAuthPolicyCommandOutput>;
+    getAuthPolicy(args: GetAuthPolicyCommandInput, cb: (err: any, data?: GetAuthPolicyCommandOutput) => void): void;
+    getAuthPolicy(args: GetAuthPolicyCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: GetAuthPolicyCommandOutput) => void): void;
+    /**
+     * @public
+     * <p>Retrieves information about the specified listener for the specified service.</p>
+     */
+    getListener(args: GetListenerCommandInput, options?: __HttpHandlerOptions): Promise<GetListenerCommandOutput>;
+    getListener(args: GetListenerCommandInput, cb: (err: any, data?: GetListenerCommandOutput) => void): void;
+    getListener(args: GetListenerCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: GetListenerCommandOutput) => void): void;
+    /**
+     * @public
+     * <p>Retrieves information about the resource policy. The resource policy is an IAM policy
+     *    created by AWS RAM on behalf of the resource owner when they share a resource.</p>
+     */
+    getResourcePolicy(args: GetResourcePolicyCommandInput, options?: __HttpHandlerOptions): Promise<GetResourcePolicyCommandOutput>;
+    getResourcePolicy(args: GetResourcePolicyCommandInput, cb: (err: any, data?: GetResourcePolicyCommandOutput) => void): void;
+    getResourcePolicy(args: GetResourcePolicyCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: GetResourcePolicyCommandOutput) => void): void;
+    /**
+     * @public
+     * <p>Retrieves information about listener rules. You can also retrieve information about the
+     *    default listener rule. For more information, see <a href="https://docs.aws.amazon.com/vpc-lattice/latest/ug/listeners.html#listener-rules">Listener rules</a> in the
+     *     <i>Amazon VPC Lattice User Guide</i>.</p>
+     */
+    getRule(args: GetRuleCommandInput, options?: __HttpHandlerOptions): Promise<GetRuleCommandOutput>;
+    getRule(args: GetRuleCommandInput, cb: (err: any, data?: GetRuleCommandOutput) => void): void;
+    getRule(args: GetRuleCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: GetRuleCommandOutput) => void): void;
+    /**
+     * @public
+     * <p>Retrieves information about the specified service.</p>
+     */
+    getService(args: GetServiceCommandInput, options?: __HttpHandlerOptions): Promise<GetServiceCommandOutput>;
+    getService(args: GetServiceCommandInput, cb: (err: any, data?: GetServiceCommandOutput) => void): void;
+    getService(args: GetServiceCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: GetServiceCommandOutput) => void): void;
+    /**
+     * @public
+     * <p>Retrieves information about the specified service network.</p>
+     */
+    getServiceNetwork(args: GetServiceNetworkCommandInput, options?: __HttpHandlerOptions): Promise<GetServiceNetworkCommandOutput>;
+    getServiceNetwork(args: GetServiceNetworkCommandInput, cb: (err: any, data?: GetServiceNetworkCommandOutput) => void): void;
+    getServiceNetwork(args: GetServiceNetworkCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: GetServiceNetworkCommandOutput) => void): void;
+    /**
+     * @public
+     * <p>Retrieves information about the specified association between a service network and a
+     *    service.</p>
+     */
+    getServiceNetworkServiceAssociation(args: GetServiceNetworkServiceAssociationCommandInput, options?: __HttpHandlerOptions): Promise<GetServiceNetworkServiceAssociationCommandOutput>;
+    getServiceNetworkServiceAssociation(args: GetServiceNetworkServiceAssociationCommandInput, cb: (err: any, data?: GetServiceNetworkServiceAssociationCommandOutput) => void): void;
+    getServiceNetworkServiceAssociation(args: GetServiceNetworkServiceAssociationCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: GetServiceNetworkServiceAssociationCommandOutput) => void): void;
+    /**
+     * @public
+     * <p>Retrieves information about the association between a service network and a VPC.</p>
+     */
+    getServiceNetworkVpcAssociation(args: GetServiceNetworkVpcAssociationCommandInput, options?: __HttpHandlerOptions): Promise<GetServiceNetworkVpcAssociationCommandOutput>;
+    getServiceNetworkVpcAssociation(args: GetServiceNetworkVpcAssociationCommandInput, cb: (err: any, data?: GetServiceNetworkVpcAssociationCommandOutput) => void): void;
+    getServiceNetworkVpcAssociation(args: GetServiceNetworkVpcAssociationCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: GetServiceNetworkVpcAssociationCommandOutput) => void): void;
+    /**
+     * @public
+     * <p>Retrieves information about the specified target group.</p>
+     */
+    getTargetGroup(args: GetTargetGroupCommandInput, options?: __HttpHandlerOptions): Promise<GetTargetGroupCommandOutput>;
+    getTargetGroup(args: GetTargetGroupCommandInput, cb: (err: any, data?: GetTargetGroupCommandOutput) => void): void;
+    getTargetGroup(args: GetTargetGroupCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: GetTargetGroupCommandOutput) => void): void;
+    /**
+     * @public
+     * <p>Lists all access log subscriptions for the specified service network or service.</p>
+     */
+    listAccessLogSubscriptions(args: ListAccessLogSubscriptionsCommandInput, options?: __HttpHandlerOptions): Promise<ListAccessLogSubscriptionsCommandOutput>;
+    listAccessLogSubscriptions(args: ListAccessLogSubscriptionsCommandInput, cb: (err: any, data?: ListAccessLogSubscriptionsCommandOutput) => void): void;
+    listAccessLogSubscriptions(args: ListAccessLogSubscriptionsCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ListAccessLogSubscriptionsCommandOutput) => void): void;
+    /**
+     * @public
+     * <p>Lists the listeners for the specified service.</p>
+     */
+    listListeners(args: ListListenersCommandInput, options?: __HttpHandlerOptions): Promise<ListListenersCommandOutput>;
+    listListeners(args: ListListenersCommandInput, cb: (err: any, data?: ListListenersCommandOutput) => void): void;
+    listListeners(args: ListListenersCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ListListenersCommandOutput) => void): void;
+    /**
+     * @public
+     * <p>Lists the rules for the listener.</p>
+     */
+    listRules(args: ListRulesCommandInput, options?: __HttpHandlerOptions): Promise<ListRulesCommandOutput>;
+    listRules(args: ListRulesCommandInput, cb: (err: any, data?: ListRulesCommandOutput) => void): void;
+    listRules(args: ListRulesCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ListRulesCommandOutput) => void): void;
+    /**
+     * @public
+     * <p>Lists the service networks owned by the caller account or shared with the caller account.
+     *    Also includes the account ID in the ARN to show which account owns the service network.</p>
+     */
+    listServiceNetworks(args: ListServiceNetworksCommandInput, options?: __HttpHandlerOptions): Promise<ListServiceNetworksCommandOutput>;
+    listServiceNetworks(args: ListServiceNetworksCommandInput, cb: (err: any, data?: ListServiceNetworksCommandOutput) => void): void;
+    listServiceNetworks(args: ListServiceNetworksCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ListServiceNetworksCommandOutput) => void): void;
+    /**
+     * @public
+     * <p>Lists the associations between the service network and the service. You can filter the list
+     *    either by service or service network. You must provide either the service network identifier or
+     *    the service identifier.</p>
+     *          <p>Every association in Amazon VPC Lattice is given a unique Amazon Resource Name (ARN), such as when a
+     *    service network is associated with a VPC or when a service is associated with a service network.
+     *    If the association is for a resource that is shared with another account, the association will
+     *    include the local account ID as the prefix in the ARN for each account the resource is shared
+     *    with.</p>
+     */
+    listServiceNetworkServiceAssociations(args: ListServiceNetworkServiceAssociationsCommandInput, options?: __HttpHandlerOptions): Promise<ListServiceNetworkServiceAssociationsCommandOutput>;
+    listServiceNetworkServiceAssociations(args: ListServiceNetworkServiceAssociationsCommandInput, cb: (err: any, data?: ListServiceNetworkServiceAssociationsCommandOutput) => void): void;
+    listServiceNetworkServiceAssociations(args: ListServiceNetworkServiceAssociationsCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ListServiceNetworkServiceAssociationsCommandOutput) => void): void;
+    /**
+     * @public
+     * <p>Lists the service network and VPC associations. You can filter the list either by VPC or
+     *    service network. You must provide either the service network identifier or the VPC
+     *    identifier.</p>
+     */
+    listServiceNetworkVpcAssociations(args: ListServiceNetworkVpcAssociationsCommandInput, options?: __HttpHandlerOptions): Promise<ListServiceNetworkVpcAssociationsCommandOutput>;
+    listServiceNetworkVpcAssociations(args: ListServiceNetworkVpcAssociationsCommandInput, cb: (err: any, data?: ListServiceNetworkVpcAssociationsCommandOutput) => void): void;
+    listServiceNetworkVpcAssociations(args: ListServiceNetworkVpcAssociationsCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ListServiceNetworkVpcAssociationsCommandOutput) => void): void;
+    /**
+     * @public
+     * <p>Lists the services owned by the caller account or shared with the caller account.</p>
+     */
+    listServices(args: ListServicesCommandInput, options?: __HttpHandlerOptions): Promise<ListServicesCommandOutput>;
+    listServices(args: ListServicesCommandInput, cb: (err: any, data?: ListServicesCommandOutput) => void): void;
+    listServices(args: ListServicesCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ListServicesCommandOutput) => void): void;
+    /**
+     * @public
+     * <p>Lists the tags for the specified resource.</p>
+     */
+    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>Lists your target groups. You can narrow your search by using the filters below in your
+     *    request.</p>
+     */
+    listTargetGroups(args: ListTargetGroupsCommandInput, options?: __HttpHandlerOptions): Promise<ListTargetGroupsCommandOutput>;
+    listTargetGroups(args: ListTargetGroupsCommandInput, cb: (err: any, data?: ListTargetGroupsCommandOutput) => void): void;
+    listTargetGroups(args: ListTargetGroupsCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ListTargetGroupsCommandOutput) => void): void;
+    /**
+     * @public
+     * <p>Lists the targets for the target group. By default, all targets are included. You can use
+     *    this API to check the health status of targets. You can also filter the results by target. </p>
+     */
+    listTargets(args: ListTargetsCommandInput, options?: __HttpHandlerOptions): Promise<ListTargetsCommandOutput>;
+    listTargets(args: ListTargetsCommandInput, cb: (err: any, data?: ListTargetsCommandOutput) => void): void;
+    listTargets(args: ListTargetsCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ListTargetsCommandOutput) => void): void;
+    /**
+     * @public
+     * <p>Creates or updates the auth policy.</p>
+     */
+    putAuthPolicy(args: PutAuthPolicyCommandInput, options?: __HttpHandlerOptions): Promise<PutAuthPolicyCommandOutput>;
+    putAuthPolicy(args: PutAuthPolicyCommandInput, cb: (err: any, data?: PutAuthPolicyCommandOutput) => void): void;
+    putAuthPolicy(args: PutAuthPolicyCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: PutAuthPolicyCommandOutput) => void): void;
+    /**
+     * @public
+     * <p>Attaches a resource-based permission policy to a service or service network. The policy must
+     *    contain the same actions and condition statements as the Amazon Web Services Resource Access
+     *    Manager permission for sharing services and service networks.</p>
+     */
+    putResourcePolicy(args: PutResourcePolicyCommandInput, options?: __HttpHandlerOptions): Promise<PutResourcePolicyCommandOutput>;
+    putResourcePolicy(args: PutResourcePolicyCommandInput, cb: (err: any, data?: PutResourcePolicyCommandOutput) => void): void;
+    putResourcePolicy(args: PutResourcePolicyCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: PutResourcePolicyCommandOutput) => void): void;
+    /**
+     * @public
+     * <p>Registers the targets with the target group. If it's a Lambda target, you can only have one
+     *    target in a target group.</p>
+     */
+    registerTargets(args: RegisterTargetsCommandInput, options?: __HttpHandlerOptions): Promise<RegisterTargetsCommandOutput>;
+    registerTargets(args: RegisterTargetsCommandInput, cb: (err: any, data?: RegisterTargetsCommandOutput) => void): void;
+    registerTargets(args: RegisterTargetsCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: RegisterTargetsCommandOutput) => void): void;
+    /**
+     * @public
+     * <p>Adds the specified tags to the specified resource.</p>
+     */
+    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 the specified tags from the specified resource.</p>
+     */
+    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 the specified access log subscription.</p>
+     */
+    updateAccessLogSubscription(args: UpdateAccessLogSubscriptionCommandInput, options?: __HttpHandlerOptions): Promise<UpdateAccessLogSubscriptionCommandOutput>;
+    updateAccessLogSubscription(args: UpdateAccessLogSubscriptionCommandInput, cb: (err: any, data?: UpdateAccessLogSubscriptionCommandOutput) => void): void;
+    updateAccessLogSubscription(args: UpdateAccessLogSubscriptionCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: UpdateAccessLogSubscriptionCommandOutput) => void): void;
+    /**
+     * @public
+     * <p>Updates the specified listener for the specified service.</p>
+     */
+    updateListener(args: UpdateListenerCommandInput, options?: __HttpHandlerOptions): Promise<UpdateListenerCommandOutput>;
+    updateListener(args: UpdateListenerCommandInput, cb: (err: any, data?: UpdateListenerCommandOutput) => void): void;
+    updateListener(args: UpdateListenerCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: UpdateListenerCommandOutput) => void): void;
+    /**
+     * @public
+     * <p>Updates a rule for the listener. You can't modify a default listener rule. To modify a
+     *    default listener rule, use <code>UpdateListener</code>.</p>
+     */
+    updateRule(args: UpdateRuleCommandInput, options?: __HttpHandlerOptions): Promise<UpdateRuleCommandOutput>;
+    updateRule(args: UpdateRuleCommandInput, cb: (err: any, data?: UpdateRuleCommandOutput) => void): void;
+    updateRule(args: UpdateRuleCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: UpdateRuleCommandOutput) => void): void;
+    /**
+     * @public
+     * <p>Updates the specified service.</p>
+     */
+    updateService(args: UpdateServiceCommandInput, options?: __HttpHandlerOptions): Promise<UpdateServiceCommandOutput>;
+    updateService(args: UpdateServiceCommandInput, cb: (err: any, data?: UpdateServiceCommandOutput) => void): void;
+    updateService(args: UpdateServiceCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: UpdateServiceCommandOutput) => void): void;
+    /**
+     * @public
+     * <p>Updates the specified service network.</p>
+     */
+    updateServiceNetwork(args: UpdateServiceNetworkCommandInput, options?: __HttpHandlerOptions): Promise<UpdateServiceNetworkCommandOutput>;
+    updateServiceNetwork(args: UpdateServiceNetworkCommandInput, cb: (err: any, data?: UpdateServiceNetworkCommandOutput) => void): void;
+    updateServiceNetwork(args: UpdateServiceNetworkCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: UpdateServiceNetworkCommandOutput) => void): void;
+    /**
+     * @public
+     * <p>Updates the service network and VPC association. Once you add a security group, it cannot be
+     *    removed.</p>
+     */
+    updateServiceNetworkVpcAssociation(args: UpdateServiceNetworkVpcAssociationCommandInput, options?: __HttpHandlerOptions): Promise<UpdateServiceNetworkVpcAssociationCommandOutput>;
+    updateServiceNetworkVpcAssociation(args: UpdateServiceNetworkVpcAssociationCommandInput, cb: (err: any, data?: UpdateServiceNetworkVpcAssociationCommandOutput) => void): void;
+    updateServiceNetworkVpcAssociation(args: UpdateServiceNetworkVpcAssociationCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: UpdateServiceNetworkVpcAssociationCommandOutput) => void): void;
+    /**
+     * @public
+     * <p>Updates the specified target group.</p>
+     */
+    updateTargetGroup(args: UpdateTargetGroupCommandInput, options?: __HttpHandlerOptions): Promise<UpdateTargetGroupCommandOutput>;
+    updateTargetGroup(args: UpdateTargetGroupCommandInput, cb: (err: any, data?: UpdateTargetGroupCommandOutput) => void): void;
+    updateTargetGroup(args: UpdateTargetGroupCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: UpdateTargetGroupCommandOutput) => void): void;
+}