@aws-sdk/client-datazone 3.1068.0 → 3.1069.0

package/dist-cjs/index.js

@@ -1,18 +1,21 @@
-'use strict';
-
-var client$1 = require('@aws-sdk/core/client');
-var core = require('@smithy/core');
-var client = require('@smithy/core/client');
-var config = require('@smithy/core/config');
-var endpoints = require('@smithy/core/endpoints');
-var protocols = require('@smithy/core/protocols');
-var retry = require('@smithy/core/retry');
-var schema = require('@smithy/core/schema');
-var httpAuthSchemeProvider = require('./auth/httpAuthSchemeProvider');
-var runtimeConfig = require('./runtimeConfig');
-var schemas_0 = require('./schemas/schemas_0');
-var errors = require('./models/errors');
-var DataZoneServiceException = require('./models/DataZoneServiceException');
+var __exportStar = (m, e) => { Object.assign(e, m); };
+const { getAwsRegionExtensionConfiguration, resolveAwsRegionExtensionConfiguration, resolveUserAgentConfig, resolveHostHeaderConfig, getUserAgentPlugin, getHostHeaderPlugin, getLoggerPlugin, getRecursionDetectionPlugin } = require("@aws-sdk/core/client");
+const { getHttpAuthSchemeEndpointRuleSetPlugin, DefaultIdentityProviderConfig, getHttpSigningPlugin, createPaginator } = require("@smithy/core");
+const { getDefaultExtensionConfiguration, resolveDefaultRuntimeConfig, Client, Command, createAggregatedClient } = require("@smithy/core/client");
+exports.$Command = Command;
+exports.__Client = Client;
+const { resolveRegionConfig } = require("@smithy/core/config");
+const { resolveEndpointConfig, getEndpointPlugin } = require("@smithy/core/endpoints");
+const { getHttpHandlerExtensionConfiguration, resolveHttpHandlerRuntimeConfig, getContentLengthPlugin } = require("@smithy/core/protocols");
+const { resolveRetryConfig, getRetryPlugin } = require("@smithy/core/retry");
+const { getSchemaSerdePlugin } = require("@smithy/core/schema");
+const { resolveHttpAuthSchemeConfig, defaultDataZoneHttpAuthSchemeParametersProvider } = require("./auth/httpAuthSchemeProvider");
+const { getRuntimeConfig } = require("./runtimeConfig");
+const { AcceptPredictions$, AcceptSubscriptionRequest$, AddEntityOwner$, AddPolicyGrant$, AssociateEnvironmentRole$, AssociateGovernedTerms$, BatchGetAttributesMetadata$, BatchPutAttributesMetadata$, CancelMetadataGenerationRun$, CancelSubscription$, CreateAccountPool$, CreateAsset$, CreateAssetFilter$, CreateAssetRevision$, CreateAssetType$, CreateConnection$, CreateDataProduct$, CreateDataProductRevision$, CreateDataSource$, CreateDomain$, CreateDomainUnit$, CreateEnvironmentAction$, CreateEnvironmentBlueprint$, CreateEnvironment$, CreateEnvironmentProfile$, CreateFormType$, CreateGlossary$, CreateGlossaryTerm$, CreateGroupProfile$, CreateListingChangeSet$, CreateNotebook$, CreateProject$, CreateProjectMembership$, CreateProjectProfile$, CreateRule$, CreateSubscriptionGrant$, CreateSubscriptionRequest$, CreateSubscriptionTarget$, CreateUserProfile$, DeleteAccountPool$, DeleteAsset$, DeleteAssetFilter$, DeleteAssetType$, DeleteConnection$, DeleteDataExportConfiguration$, DeleteDataProduct$, DeleteDataSource$, DeleteDomain$, DeleteDomainUnit$, DeleteEnvironmentAction$, DeleteEnvironmentBlueprint$, DeleteEnvironmentBlueprintConfiguration$, DeleteEnvironment$, DeleteEnvironmentProfile$, DeleteFormType$, DeleteGlossary$, DeleteGlossaryTerm$, DeleteLineageEvent$, DeleteListing$, DeleteNotebook$, DeleteProject$, DeleteProjectMembership$, DeleteProjectProfile$, DeleteRule$, DeleteSubscriptionGrant$, DeleteSubscriptionRequest$, DeleteSubscriptionTarget$, DeleteTimeSeriesDataPoints$, DisassociateEnvironmentRole$, DisassociateGovernedTerms$, GetAccountPool$, GetAsset$, GetAssetFilter$, GetAssetType$, GetConnection$, GetDataExportConfiguration$, GetDataProduct$, GetDataSource$, GetDataSourceRun$, GetDomain$, GetDomainUnit$, GetEnvironmentAction$, GetEnvironmentBlueprint$, GetEnvironmentBlueprintConfiguration$, GetEnvironment$, GetEnvironmentCredentials$, GetEnvironmentProfile$, GetFormType$, GetGlossary$, GetGlossaryTerm$, GetGroupProfile$, GetIamPortalLoginUrl$, GetJobRun$, GetLineageEvent$, GetLineageNode$, GetListing$, GetMetadataGenerationRun$, GetNotebook$, GetNotebookExport$, GetNotebookRun$, GetProject$, GetProjectProfile$, GetRule$, GetSubscription$, GetSubscriptionGrant$, GetSubscriptionRequestDetails$, GetSubscriptionTarget$, GetTimeSeriesDataPoint$, GetUserProfile$, ListAccountPools$, ListAccountsInAccountPool$, ListAssetFilters$, ListAssetRevisions$, ListConnections$, ListDataProductRevisions$, ListDataSourceRunActivities$, ListDataSourceRuns$, ListDataSources$, ListDomains$, ListDomainUnitsForParent$, ListEntityOwners$, ListEnvironmentActions$, ListEnvironmentBlueprintConfigurations$, ListEnvironmentBlueprints$, ListEnvironmentProfiles$, ListEnvironments$, ListJobRuns$, ListLineageEvents$, ListLineageNodeHistory$, ListMetadataGenerationRuns$, ListNotebookRuns$, ListNotebooks$, ListNotifications$, ListPolicyGrants$, ListProjectMemberships$, ListProjectProfiles$, ListProjects$, ListRules$, ListSubscriptionGrants$, ListSubscriptionRequests$, ListSubscriptions$, ListSubscriptionTargets$, ListTagsForResource$, ListTimeSeriesDataPoints$, PostLineageEvent$, PostTimeSeriesDataPoints$, PutDataExportConfiguration$, PutEnvironmentBlueprintConfiguration$, QueryGraph$, RejectPredictions$, RejectSubscriptionRequest$, RemoveEntityOwner$, RemovePolicyGrant$, RevokeSubscription$, Search$, SearchGroupProfiles$, SearchListings$, SearchTypes$, SearchUserProfiles$, StartDataSourceRun$, StartMetadataGenerationRun$, StartNotebookExport$, StartNotebookImport$, StartNotebookRun$, StopNotebookRun$, TagResource$, UntagResource$, UpdateAccountPool$, UpdateAssetFilter$, UpdateConnection$, UpdateDataSource$, UpdateDomain$, UpdateDomainUnit$, UpdateEnvironmentAction$, UpdateEnvironmentBlueprint$, UpdateEnvironment$, UpdateEnvironmentProfile$, UpdateGlossary$, UpdateGlossaryTerm$, UpdateGroupProfile$, UpdateNotebook$, UpdateProject$, UpdateProjectProfile$, UpdateRootDomainUnitOwner$, UpdateRule$, UpdateSubscriptionGrantStatus$, UpdateSubscriptionRequest$, UpdateSubscriptionTarget$, UpdateUserProfile$ } = require("./schemas/schemas_0");
+__exportStar(require("./schemas/schemas_0"), exports);
+__exportStar(require("./models/errors"), exports);
+const { DataZoneServiceException } = require("./models/DataZoneServiceException");
+exports.DataZoneServiceException = DataZoneServiceException;
 
 const resolveClientEndpointParameters = (options) => {
     return Object.assign(options, {
@@ -66,2381 +69,2393 @@ const resolveHttpAuthRuntimeConfig = (config) => {
 };
 
 const resolveRuntimeExtensions = (runtimeConfig, extensions) => {
-    const extensionConfiguration = Object.assign(client$1.getAwsRegionExtensionConfiguration(runtimeConfig), client.getDefaultExtensionConfiguration(runtimeConfig), protocols.getHttpHandlerExtensionConfiguration(runtimeConfig), getHttpAuthExtensionConfiguration(runtimeConfig));
+    const extensionConfiguration = Object.assign(getAwsRegionExtensionConfiguration(runtimeConfig), getDefaultExtensionConfiguration(runtimeConfig), getHttpHandlerExtensionConfiguration(runtimeConfig), getHttpAuthExtensionConfiguration(runtimeConfig));
     extensions.forEach((extension) => extension.configure(extensionConfiguration));
-    return Object.assign(runtimeConfig, client$1.resolveAwsRegionExtensionConfiguration(extensionConfiguration), client.resolveDefaultRuntimeConfig(extensionConfiguration), protocols.resolveHttpHandlerRuntimeConfig(extensionConfiguration), resolveHttpAuthRuntimeConfig(extensionConfiguration));
+    return Object.assign(runtimeConfig, resolveAwsRegionExtensionConfiguration(extensionConfiguration), resolveDefaultRuntimeConfig(extensionConfiguration), resolveHttpHandlerRuntimeConfig(extensionConfiguration), resolveHttpAuthRuntimeConfig(extensionConfiguration));
 };
 
-class DataZoneClient extends client.Client {
+class DataZoneClient extends Client {
     config;
     constructor(...[configuration]) {
-        const _config_0 = runtimeConfig.getRuntimeConfig(configuration || {});
+        const _config_0 = getRuntimeConfig(configuration || {});
         super(_config_0);
         this.initConfig = _config_0;
         const _config_1 = resolveClientEndpointParameters(_config_0);
-        const _config_2 = client$1.resolveUserAgentConfig(_config_1);
-        const _config_3 = retry.resolveRetryConfig(_config_2);
-        const _config_4 = config.resolveRegionConfig(_config_3);
-        const _config_5 = client$1.resolveHostHeaderConfig(_config_4);
-        const _config_6 = endpoints.resolveEndpointConfig(_config_5);
-        const _config_7 = httpAuthSchemeProvider.resolveHttpAuthSchemeConfig(_config_6);
+        const _config_2 = resolveUserAgentConfig(_config_1);
+        const _config_3 = resolveRetryConfig(_config_2);
+        const _config_4 = resolveRegionConfig(_config_3);
+        const _config_5 = resolveHostHeaderConfig(_config_4);
+        const _config_6 = resolveEndpointConfig(_config_5);
+        const _config_7 = resolveHttpAuthSchemeConfig(_config_6);
         const _config_8 = resolveRuntimeExtensions(_config_7, configuration?.extensions || []);
         this.config = _config_8;
-        this.middlewareStack.use(schema.getSchemaSerdePlugin(this.config));
-        this.middlewareStack.use(client$1.getUserAgentPlugin(this.config));
-        this.middlewareStack.use(retry.getRetryPlugin(this.config));
-        this.middlewareStack.use(protocols.getContentLengthPlugin(this.config));
-        this.middlewareStack.use(client$1.getHostHeaderPlugin(this.config));
-        this.middlewareStack.use(client$1.getLoggerPlugin(this.config));
-        this.middlewareStack.use(client$1.getRecursionDetectionPlugin(this.config));
-        this.middlewareStack.use(core.getHttpAuthSchemeEndpointRuleSetPlugin(this.config, {
-            httpAuthSchemeParametersProvider: httpAuthSchemeProvider.defaultDataZoneHttpAuthSchemeParametersProvider,
-            identityProviderConfigProvider: async (config) => new core.DefaultIdentityProviderConfig({
+        this.middlewareStack.use(getSchemaSerdePlugin(this.config));
+        this.middlewareStack.use(getUserAgentPlugin(this.config));
+        this.middlewareStack.use(getRetryPlugin(this.config));
+        this.middlewareStack.use(getContentLengthPlugin(this.config));
+        this.middlewareStack.use(getHostHeaderPlugin(this.config));
+        this.middlewareStack.use(getLoggerPlugin(this.config));
+        this.middlewareStack.use(getRecursionDetectionPlugin(this.config));
+        this.middlewareStack.use(getHttpAuthSchemeEndpointRuleSetPlugin(this.config, {
+            httpAuthSchemeParametersProvider: defaultDataZoneHttpAuthSchemeParametersProvider,
+            identityProviderConfigProvider: async (config) => new DefaultIdentityProviderConfig({
                 "aws.auth#sigv4": config.credentials,
             }),
         }));
-        this.middlewareStack.use(core.getHttpSigningPlugin(this.config));
+        this.middlewareStack.use(getHttpSigningPlugin(this.config));
     }
     destroy() {
         super.destroy();
     }
 }
 
-class AcceptPredictionsCommand extends client.Command
+class AcceptPredictionsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "AcceptPredictions", {})
     .n("DataZoneClient", "AcceptPredictionsCommand")
-    .sc(schemas_0.AcceptPredictions$)
+    .sc(AcceptPredictions$)
     .build() {
 }
 
-class AcceptSubscriptionRequestCommand extends client.Command
+class AcceptSubscriptionRequestCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "AcceptSubscriptionRequest", {})
     .n("DataZoneClient", "AcceptSubscriptionRequestCommand")
-    .sc(schemas_0.AcceptSubscriptionRequest$)
+    .sc(AcceptSubscriptionRequest$)
     .build() {
 }
 
-class AddEntityOwnerCommand extends client.Command
+class AddEntityOwnerCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "AddEntityOwner", {})
     .n("DataZoneClient", "AddEntityOwnerCommand")
-    .sc(schemas_0.AddEntityOwner$)
+    .sc(AddEntityOwner$)
     .build() {
 }
 
-class AddPolicyGrantCommand extends client.Command
+class AddPolicyGrantCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "AddPolicyGrant", {})
     .n("DataZoneClient", "AddPolicyGrantCommand")
-    .sc(schemas_0.AddPolicyGrant$)
+    .sc(AddPolicyGrant$)
     .build() {
 }
 
-class AssociateEnvironmentRoleCommand extends client.Command
+class AssociateEnvironmentRoleCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "AssociateEnvironmentRole", {})
     .n("DataZoneClient", "AssociateEnvironmentRoleCommand")
-    .sc(schemas_0.AssociateEnvironmentRole$)
+    .sc(AssociateEnvironmentRole$)
     .build() {
 }
 
-class AssociateGovernedTermsCommand extends client.Command
+class AssociateGovernedTermsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "AssociateGovernedTerms", {})
     .n("DataZoneClient", "AssociateGovernedTermsCommand")
-    .sc(schemas_0.AssociateGovernedTerms$)
+    .sc(AssociateGovernedTerms$)
     .build() {
 }
 
-class BatchGetAttributesMetadataCommand extends client.Command
+class BatchGetAttributesMetadataCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "BatchGetAttributesMetadata", {})
     .n("DataZoneClient", "BatchGetAttributesMetadataCommand")
-    .sc(schemas_0.BatchGetAttributesMetadata$)
+    .sc(BatchGetAttributesMetadata$)
     .build() {
 }
 
-class BatchPutAttributesMetadataCommand extends client.Command
+class BatchPutAttributesMetadataCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "BatchPutAttributesMetadata", {})
     .n("DataZoneClient", "BatchPutAttributesMetadataCommand")
-    .sc(schemas_0.BatchPutAttributesMetadata$)
+    .sc(BatchPutAttributesMetadata$)
     .build() {
 }
 
-class CancelMetadataGenerationRunCommand extends client.Command
+class CancelMetadataGenerationRunCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "CancelMetadataGenerationRun", {})
     .n("DataZoneClient", "CancelMetadataGenerationRunCommand")
-    .sc(schemas_0.CancelMetadataGenerationRun$)
+    .sc(CancelMetadataGenerationRun$)
     .build() {
 }
 
-class CancelSubscriptionCommand extends client.Command
+class CancelSubscriptionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "CancelSubscription", {})
     .n("DataZoneClient", "CancelSubscriptionCommand")
-    .sc(schemas_0.CancelSubscription$)
+    .sc(CancelSubscription$)
     .build() {
 }
 
-class CreateAccountPoolCommand extends client.Command
+class CreateAccountPoolCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "CreateAccountPool", {})
     .n("DataZoneClient", "CreateAccountPoolCommand")
-    .sc(schemas_0.CreateAccountPool$)
+    .sc(CreateAccountPool$)
     .build() {
 }
 
-class CreateAssetCommand extends client.Command
+class CreateAssetCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "CreateAsset", {})
     .n("DataZoneClient", "CreateAssetCommand")
-    .sc(schemas_0.CreateAsset$)
+    .sc(CreateAsset$)
     .build() {
 }
 
-class CreateAssetFilterCommand extends client.Command
+class CreateAssetFilterCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "CreateAssetFilter", {})
     .n("DataZoneClient", "CreateAssetFilterCommand")
-    .sc(schemas_0.CreateAssetFilter$)
+    .sc(CreateAssetFilter$)
     .build() {
 }
 
-class CreateAssetRevisionCommand extends client.Command
+class CreateAssetRevisionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "CreateAssetRevision", {})
     .n("DataZoneClient", "CreateAssetRevisionCommand")
-    .sc(schemas_0.CreateAssetRevision$)
+    .sc(CreateAssetRevision$)
     .build() {
 }
 
-class CreateAssetTypeCommand extends client.Command
+class CreateAssetTypeCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "CreateAssetType", {})
     .n("DataZoneClient", "CreateAssetTypeCommand")
-    .sc(schemas_0.CreateAssetType$)
+    .sc(CreateAssetType$)
     .build() {
 }
 
-class CreateConnectionCommand extends client.Command
+class CreateConnectionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "CreateConnection", {})
     .n("DataZoneClient", "CreateConnectionCommand")
-    .sc(schemas_0.CreateConnection$)
+    .sc(CreateConnection$)
     .build() {
 }
 
-class CreateDataProductCommand extends client.Command
+class CreateDataProductCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "CreateDataProduct", {})
     .n("DataZoneClient", "CreateDataProductCommand")
-    .sc(schemas_0.CreateDataProduct$)
+    .sc(CreateDataProduct$)
     .build() {
 }
 
-class CreateDataProductRevisionCommand extends client.Command
+class CreateDataProductRevisionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "CreateDataProductRevision", {})
     .n("DataZoneClient", "CreateDataProductRevisionCommand")
-    .sc(schemas_0.CreateDataProductRevision$)
+    .sc(CreateDataProductRevision$)
     .build() {
 }
 
-class CreateDataSourceCommand extends client.Command
+class CreateDataSourceCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "CreateDataSource", {})
     .n("DataZoneClient", "CreateDataSourceCommand")
-    .sc(schemas_0.CreateDataSource$)
+    .sc(CreateDataSource$)
     .build() {
 }
 
-class CreateDomainCommand extends client.Command
+class CreateDomainCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "CreateDomain", {})
     .n("DataZoneClient", "CreateDomainCommand")
-    .sc(schemas_0.CreateDomain$)
+    .sc(CreateDomain$)
     .build() {
 }
 
-class CreateDomainUnitCommand extends client.Command
+class CreateDomainUnitCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "CreateDomainUnit", {})
     .n("DataZoneClient", "CreateDomainUnitCommand")
-    .sc(schemas_0.CreateDomainUnit$)
+    .sc(CreateDomainUnit$)
     .build() {
 }
 
-class CreateEnvironmentActionCommand extends client.Command
+class CreateEnvironmentActionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "CreateEnvironmentAction", {})
     .n("DataZoneClient", "CreateEnvironmentActionCommand")
-    .sc(schemas_0.CreateEnvironmentAction$)
+    .sc(CreateEnvironmentAction$)
     .build() {
 }
 
-class CreateEnvironmentBlueprintCommand extends client.Command
+class CreateEnvironmentBlueprintCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "CreateEnvironmentBlueprint", {})
     .n("DataZoneClient", "CreateEnvironmentBlueprintCommand")
-    .sc(schemas_0.CreateEnvironmentBlueprint$)
+    .sc(CreateEnvironmentBlueprint$)
     .build() {
 }
 
-class CreateEnvironmentCommand extends client.Command
+class CreateEnvironmentCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "CreateEnvironment", {})
     .n("DataZoneClient", "CreateEnvironmentCommand")
-    .sc(schemas_0.CreateEnvironment$)
+    .sc(CreateEnvironment$)
     .build() {
 }
 
-class CreateEnvironmentProfileCommand extends client.Command
+class CreateEnvironmentProfileCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "CreateEnvironmentProfile", {})
     .n("DataZoneClient", "CreateEnvironmentProfileCommand")
-    .sc(schemas_0.CreateEnvironmentProfile$)
+    .sc(CreateEnvironmentProfile$)
     .build() {
 }
 
-class CreateFormTypeCommand extends client.Command
+class CreateFormTypeCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "CreateFormType", {})
     .n("DataZoneClient", "CreateFormTypeCommand")
-    .sc(schemas_0.CreateFormType$)
+    .sc(CreateFormType$)
     .build() {
 }
 
-class CreateGlossaryCommand extends client.Command
+class CreateGlossaryCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "CreateGlossary", {})
     .n("DataZoneClient", "CreateGlossaryCommand")
-    .sc(schemas_0.CreateGlossary$)
+    .sc(CreateGlossary$)
     .build() {
 }
 
-class CreateGlossaryTermCommand extends client.Command
+class CreateGlossaryTermCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "CreateGlossaryTerm", {})
     .n("DataZoneClient", "CreateGlossaryTermCommand")
-    .sc(schemas_0.CreateGlossaryTerm$)
+    .sc(CreateGlossaryTerm$)
     .build() {
 }
 
-class CreateGroupProfileCommand extends client.Command
+class CreateGroupProfileCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "CreateGroupProfile", {})
     .n("DataZoneClient", "CreateGroupProfileCommand")
-    .sc(schemas_0.CreateGroupProfile$)
+    .sc(CreateGroupProfile$)
     .build() {
 }
 
-class CreateListingChangeSetCommand extends client.Command
+class CreateListingChangeSetCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "CreateListingChangeSet", {})
     .n("DataZoneClient", "CreateListingChangeSetCommand")
-    .sc(schemas_0.CreateListingChangeSet$)
+    .sc(CreateListingChangeSet$)
     .build() {
 }
 
-class CreateNotebookCommand extends client.Command
+class CreateNotebookCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "CreateNotebook", {})
     .n("DataZoneClient", "CreateNotebookCommand")
-    .sc(schemas_0.CreateNotebook$)
+    .sc(CreateNotebook$)
     .build() {
 }
 
-class CreateProjectCommand extends client.Command
+class CreateProjectCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "CreateProject", {})
     .n("DataZoneClient", "CreateProjectCommand")
-    .sc(schemas_0.CreateProject$)
+    .sc(CreateProject$)
     .build() {
 }
 
-class CreateProjectMembershipCommand extends client.Command
+class CreateProjectMembershipCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "CreateProjectMembership", {})
     .n("DataZoneClient", "CreateProjectMembershipCommand")
-    .sc(schemas_0.CreateProjectMembership$)
+    .sc(CreateProjectMembership$)
     .build() {
 }
 
-class CreateProjectProfileCommand extends client.Command
+class CreateProjectProfileCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "CreateProjectProfile", {})
     .n("DataZoneClient", "CreateProjectProfileCommand")
-    .sc(schemas_0.CreateProjectProfile$)
+    .sc(CreateProjectProfile$)
     .build() {
 }
 
-class CreateRuleCommand extends client.Command
+class CreateRuleCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "CreateRule", {})
     .n("DataZoneClient", "CreateRuleCommand")
-    .sc(schemas_0.CreateRule$)
+    .sc(CreateRule$)
     .build() {
 }
 
-class CreateSubscriptionGrantCommand extends client.Command
+class CreateSubscriptionGrantCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "CreateSubscriptionGrant", {})
     .n("DataZoneClient", "CreateSubscriptionGrantCommand")
-    .sc(schemas_0.CreateSubscriptionGrant$)
+    .sc(CreateSubscriptionGrant$)
     .build() {
 }
 
-class CreateSubscriptionRequestCommand extends client.Command
+class CreateSubscriptionRequestCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "CreateSubscriptionRequest", {})
     .n("DataZoneClient", "CreateSubscriptionRequestCommand")
-    .sc(schemas_0.CreateSubscriptionRequest$)
+    .sc(CreateSubscriptionRequest$)
     .build() {
 }
 
-class CreateSubscriptionTargetCommand extends client.Command
+class CreateSubscriptionTargetCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "CreateSubscriptionTarget", {})
     .n("DataZoneClient", "CreateSubscriptionTargetCommand")
-    .sc(schemas_0.CreateSubscriptionTarget$)
+    .sc(CreateSubscriptionTarget$)
     .build() {
 }
 
-class CreateUserProfileCommand extends client.Command
+class CreateUserProfileCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "CreateUserProfile", {})
     .n("DataZoneClient", "CreateUserProfileCommand")
-    .sc(schemas_0.CreateUserProfile$)
+    .sc(CreateUserProfile$)
     .build() {
 }
 
-class DeleteAccountPoolCommand extends client.Command
+class DeleteAccountPoolCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "DeleteAccountPool", {})
     .n("DataZoneClient", "DeleteAccountPoolCommand")
-    .sc(schemas_0.DeleteAccountPool$)
+    .sc(DeleteAccountPool$)
     .build() {
 }
 
-class DeleteAssetCommand extends client.Command
+class DeleteAssetCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "DeleteAsset", {})
     .n("DataZoneClient", "DeleteAssetCommand")
-    .sc(schemas_0.DeleteAsset$)
+    .sc(DeleteAsset$)
     .build() {
 }
 
-class DeleteAssetFilterCommand extends client.Command
+class DeleteAssetFilterCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "DeleteAssetFilter", {})
     .n("DataZoneClient", "DeleteAssetFilterCommand")
-    .sc(schemas_0.DeleteAssetFilter$)
+    .sc(DeleteAssetFilter$)
     .build() {
 }
 
-class DeleteAssetTypeCommand extends client.Command
+class DeleteAssetTypeCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "DeleteAssetType", {})
     .n("DataZoneClient", "DeleteAssetTypeCommand")
-    .sc(schemas_0.DeleteAssetType$)
+    .sc(DeleteAssetType$)
     .build() {
 }
 
-class DeleteConnectionCommand extends client.Command
+class DeleteConnectionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "DeleteConnection", {})
     .n("DataZoneClient", "DeleteConnectionCommand")
-    .sc(schemas_0.DeleteConnection$)
+    .sc(DeleteConnection$)
     .build() {
 }
 
-class DeleteDataExportConfigurationCommand extends client.Command
+class DeleteDataExportConfigurationCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "DeleteDataExportConfiguration", {})
     .n("DataZoneClient", "DeleteDataExportConfigurationCommand")
-    .sc(schemas_0.DeleteDataExportConfiguration$)
+    .sc(DeleteDataExportConfiguration$)
     .build() {
 }
 
-class DeleteDataProductCommand extends client.Command
+class DeleteDataProductCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "DeleteDataProduct", {})
     .n("DataZoneClient", "DeleteDataProductCommand")
-    .sc(schemas_0.DeleteDataProduct$)
+    .sc(DeleteDataProduct$)
     .build() {
 }
 
-class DeleteDataSourceCommand extends client.Command
+class DeleteDataSourceCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "DeleteDataSource", {})
     .n("DataZoneClient", "DeleteDataSourceCommand")
-    .sc(schemas_0.DeleteDataSource$)
+    .sc(DeleteDataSource$)
     .build() {
 }
 
-class DeleteDomainCommand extends client.Command
+class DeleteDomainCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "DeleteDomain", {})
     .n("DataZoneClient", "DeleteDomainCommand")
-    .sc(schemas_0.DeleteDomain$)
+    .sc(DeleteDomain$)
     .build() {
 }
 
-class DeleteDomainUnitCommand extends client.Command
+class DeleteDomainUnitCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "DeleteDomainUnit", {})
     .n("DataZoneClient", "DeleteDomainUnitCommand")
-    .sc(schemas_0.DeleteDomainUnit$)
+    .sc(DeleteDomainUnit$)
     .build() {
 }
 
-class DeleteEnvironmentActionCommand extends client.Command
+class DeleteEnvironmentActionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "DeleteEnvironmentAction", {})
     .n("DataZoneClient", "DeleteEnvironmentActionCommand")
-    .sc(schemas_0.DeleteEnvironmentAction$)
+    .sc(DeleteEnvironmentAction$)
     .build() {
 }
 
-class DeleteEnvironmentBlueprintCommand extends client.Command
+class DeleteEnvironmentBlueprintCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "DeleteEnvironmentBlueprint", {})
     .n("DataZoneClient", "DeleteEnvironmentBlueprintCommand")
-    .sc(schemas_0.DeleteEnvironmentBlueprint$)
+    .sc(DeleteEnvironmentBlueprint$)
     .build() {
 }
 
-class DeleteEnvironmentBlueprintConfigurationCommand extends client.Command
+class DeleteEnvironmentBlueprintConfigurationCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "DeleteEnvironmentBlueprintConfiguration", {})
     .n("DataZoneClient", "DeleteEnvironmentBlueprintConfigurationCommand")
-    .sc(schemas_0.DeleteEnvironmentBlueprintConfiguration$)
+    .sc(DeleteEnvironmentBlueprintConfiguration$)
     .build() {
 }
 
-class DeleteEnvironmentCommand extends client.Command
+class DeleteEnvironmentCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "DeleteEnvironment", {})
     .n("DataZoneClient", "DeleteEnvironmentCommand")
-    .sc(schemas_0.DeleteEnvironment$)
+    .sc(DeleteEnvironment$)
     .build() {
 }
 
-class DeleteEnvironmentProfileCommand extends client.Command
+class DeleteEnvironmentProfileCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "DeleteEnvironmentProfile", {})
     .n("DataZoneClient", "DeleteEnvironmentProfileCommand")
-    .sc(schemas_0.DeleteEnvironmentProfile$)
+    .sc(DeleteEnvironmentProfile$)
     .build() {
 }
 
-class DeleteFormTypeCommand extends client.Command
+class DeleteFormTypeCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "DeleteFormType", {})
     .n("DataZoneClient", "DeleteFormTypeCommand")
-    .sc(schemas_0.DeleteFormType$)
+    .sc(DeleteFormType$)
     .build() {
 }
 
-class DeleteGlossaryCommand extends client.Command
+class DeleteGlossaryCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "DeleteGlossary", {})
     .n("DataZoneClient", "DeleteGlossaryCommand")
-    .sc(schemas_0.DeleteGlossary$)
+    .sc(DeleteGlossary$)
     .build() {
 }
 
-class DeleteGlossaryTermCommand extends client.Command
+class DeleteGlossaryTermCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "DeleteGlossaryTerm", {})
     .n("DataZoneClient", "DeleteGlossaryTermCommand")
-    .sc(schemas_0.DeleteGlossaryTerm$)
+    .sc(DeleteGlossaryTerm$)
     .build() {
 }
 
-class DeleteListingCommand extends client.Command
+class DeleteLineageEventCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+})
+    .s("DataZone", "DeleteLineageEvent", {})
+    .n("DataZoneClient", "DeleteLineageEventCommand")
+    .sc(DeleteLineageEvent$)
+    .build() {
+}
+
+class DeleteListingCommand extends Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "DeleteListing", {})
     .n("DataZoneClient", "DeleteListingCommand")
-    .sc(schemas_0.DeleteListing$)
+    .sc(DeleteListing$)
     .build() {
 }
 
-class DeleteNotebookCommand extends client.Command
+class DeleteNotebookCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "DeleteNotebook", {})
     .n("DataZoneClient", "DeleteNotebookCommand")
-    .sc(schemas_0.DeleteNotebook$)
+    .sc(DeleteNotebook$)
     .build() {
 }
 
-class DeleteProjectCommand extends client.Command
+class DeleteProjectCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "DeleteProject", {})
     .n("DataZoneClient", "DeleteProjectCommand")
-    .sc(schemas_0.DeleteProject$)
+    .sc(DeleteProject$)
     .build() {
 }
 
-class DeleteProjectMembershipCommand extends client.Command
+class DeleteProjectMembershipCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "DeleteProjectMembership", {})
     .n("DataZoneClient", "DeleteProjectMembershipCommand")
-    .sc(schemas_0.DeleteProjectMembership$)
+    .sc(DeleteProjectMembership$)
     .build() {
 }
 
-class DeleteProjectProfileCommand extends client.Command
+class DeleteProjectProfileCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "DeleteProjectProfile", {})
     .n("DataZoneClient", "DeleteProjectProfileCommand")
-    .sc(schemas_0.DeleteProjectProfile$)
+    .sc(DeleteProjectProfile$)
     .build() {
 }
 
-class DeleteRuleCommand extends client.Command
+class DeleteRuleCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "DeleteRule", {})
     .n("DataZoneClient", "DeleteRuleCommand")
-    .sc(schemas_0.DeleteRule$)
+    .sc(DeleteRule$)
     .build() {
 }
 
-class DeleteSubscriptionGrantCommand extends client.Command
+class DeleteSubscriptionGrantCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "DeleteSubscriptionGrant", {})
     .n("DataZoneClient", "DeleteSubscriptionGrantCommand")
-    .sc(schemas_0.DeleteSubscriptionGrant$)
+    .sc(DeleteSubscriptionGrant$)
     .build() {
 }
 
-class DeleteSubscriptionRequestCommand extends client.Command
+class DeleteSubscriptionRequestCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "DeleteSubscriptionRequest", {})
     .n("DataZoneClient", "DeleteSubscriptionRequestCommand")
-    .sc(schemas_0.DeleteSubscriptionRequest$)
+    .sc(DeleteSubscriptionRequest$)
     .build() {
 }
 
-class DeleteSubscriptionTargetCommand extends client.Command
+class DeleteSubscriptionTargetCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "DeleteSubscriptionTarget", {})
     .n("DataZoneClient", "DeleteSubscriptionTargetCommand")
-    .sc(schemas_0.DeleteSubscriptionTarget$)
+    .sc(DeleteSubscriptionTarget$)
     .build() {
 }
 
-class DeleteTimeSeriesDataPointsCommand extends client.Command
+class DeleteTimeSeriesDataPointsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "DeleteTimeSeriesDataPoints", {})
     .n("DataZoneClient", "DeleteTimeSeriesDataPointsCommand")
-    .sc(schemas_0.DeleteTimeSeriesDataPoints$)
+    .sc(DeleteTimeSeriesDataPoints$)
     .build() {
 }
 
-class DisassociateEnvironmentRoleCommand extends client.Command
+class DisassociateEnvironmentRoleCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "DisassociateEnvironmentRole", {})
     .n("DataZoneClient", "DisassociateEnvironmentRoleCommand")
-    .sc(schemas_0.DisassociateEnvironmentRole$)
+    .sc(DisassociateEnvironmentRole$)
     .build() {
 }
 
-class DisassociateGovernedTermsCommand extends client.Command
+class DisassociateGovernedTermsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "DisassociateGovernedTerms", {})
     .n("DataZoneClient", "DisassociateGovernedTermsCommand")
-    .sc(schemas_0.DisassociateGovernedTerms$)
+    .sc(DisassociateGovernedTerms$)
     .build() {
 }
 
-class GetAccountPoolCommand extends client.Command
+class GetAccountPoolCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "GetAccountPool", {})
     .n("DataZoneClient", "GetAccountPoolCommand")
-    .sc(schemas_0.GetAccountPool$)
+    .sc(GetAccountPool$)
     .build() {
 }
 
-class GetAssetCommand extends client.Command
+class GetAssetCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "GetAsset", {})
     .n("DataZoneClient", "GetAssetCommand")
-    .sc(schemas_0.GetAsset$)
+    .sc(GetAsset$)
     .build() {
 }
 
-class GetAssetFilterCommand extends client.Command
+class GetAssetFilterCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "GetAssetFilter", {})
     .n("DataZoneClient", "GetAssetFilterCommand")
-    .sc(schemas_0.GetAssetFilter$)
+    .sc(GetAssetFilter$)
     .build() {
 }
 
-class GetAssetTypeCommand extends client.Command
+class GetAssetTypeCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "GetAssetType", {})
     .n("DataZoneClient", "GetAssetTypeCommand")
-    .sc(schemas_0.GetAssetType$)
+    .sc(GetAssetType$)
     .build() {
 }
 
-class GetConnectionCommand extends client.Command
+class GetConnectionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "GetConnection", {})
     .n("DataZoneClient", "GetConnectionCommand")
-    .sc(schemas_0.GetConnection$)
+    .sc(GetConnection$)
     .build() {
 }
 
-class GetDataExportConfigurationCommand extends client.Command
+class GetDataExportConfigurationCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "GetDataExportConfiguration", {})
     .n("DataZoneClient", "GetDataExportConfigurationCommand")
-    .sc(schemas_0.GetDataExportConfiguration$)
+    .sc(GetDataExportConfiguration$)
     .build() {
 }
 
-class GetDataProductCommand extends client.Command
+class GetDataProductCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "GetDataProduct", {})
     .n("DataZoneClient", "GetDataProductCommand")
-    .sc(schemas_0.GetDataProduct$)
+    .sc(GetDataProduct$)
     .build() {
 }
 
-class GetDataSourceCommand extends client.Command
+class GetDataSourceCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "GetDataSource", {})
     .n("DataZoneClient", "GetDataSourceCommand")
-    .sc(schemas_0.GetDataSource$)
+    .sc(GetDataSource$)
     .build() {
 }
 
-class GetDataSourceRunCommand extends client.Command
+class GetDataSourceRunCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "GetDataSourceRun", {})
     .n("DataZoneClient", "GetDataSourceRunCommand")
-    .sc(schemas_0.GetDataSourceRun$)
+    .sc(GetDataSourceRun$)
     .build() {
 }
 
-class GetDomainCommand extends client.Command
+class GetDomainCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "GetDomain", {})
     .n("DataZoneClient", "GetDomainCommand")
-    .sc(schemas_0.GetDomain$)
+    .sc(GetDomain$)
     .build() {
 }
 
-class GetDomainUnitCommand extends client.Command
+class GetDomainUnitCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "GetDomainUnit", {})
     .n("DataZoneClient", "GetDomainUnitCommand")
-    .sc(schemas_0.GetDomainUnit$)
+    .sc(GetDomainUnit$)
     .build() {
 }
 
-class GetEnvironmentActionCommand extends client.Command
+class GetEnvironmentActionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "GetEnvironmentAction", {})
     .n("DataZoneClient", "GetEnvironmentActionCommand")
-    .sc(schemas_0.GetEnvironmentAction$)
+    .sc(GetEnvironmentAction$)
     .build() {
 }
 
-class GetEnvironmentBlueprintCommand extends client.Command
+class GetEnvironmentBlueprintCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "GetEnvironmentBlueprint", {})
     .n("DataZoneClient", "GetEnvironmentBlueprintCommand")
-    .sc(schemas_0.GetEnvironmentBlueprint$)
+    .sc(GetEnvironmentBlueprint$)
     .build() {
 }
 
-class GetEnvironmentBlueprintConfigurationCommand extends client.Command
+class GetEnvironmentBlueprintConfigurationCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "GetEnvironmentBlueprintConfiguration", {})
     .n("DataZoneClient", "GetEnvironmentBlueprintConfigurationCommand")
-    .sc(schemas_0.GetEnvironmentBlueprintConfiguration$)
+    .sc(GetEnvironmentBlueprintConfiguration$)
     .build() {
 }
 
-class GetEnvironmentCommand extends client.Command
+class GetEnvironmentCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "GetEnvironment", {})
     .n("DataZoneClient", "GetEnvironmentCommand")
-    .sc(schemas_0.GetEnvironment$)
+    .sc(GetEnvironment$)
     .build() {
 }
 
-class GetEnvironmentCredentialsCommand extends client.Command
+class GetEnvironmentCredentialsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "GetEnvironmentCredentials", {})
     .n("DataZoneClient", "GetEnvironmentCredentialsCommand")
-    .sc(schemas_0.GetEnvironmentCredentials$)
+    .sc(GetEnvironmentCredentials$)
     .build() {
 }
 
-class GetEnvironmentProfileCommand extends client.Command
+class GetEnvironmentProfileCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "GetEnvironmentProfile", {})
     .n("DataZoneClient", "GetEnvironmentProfileCommand")
-    .sc(schemas_0.GetEnvironmentProfile$)
+    .sc(GetEnvironmentProfile$)
     .build() {
 }
 
-class GetFormTypeCommand extends client.Command
+class GetFormTypeCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "GetFormType", {})
     .n("DataZoneClient", "GetFormTypeCommand")
-    .sc(schemas_0.GetFormType$)
+    .sc(GetFormType$)
     .build() {
 }
 
-class GetGlossaryCommand extends client.Command
+class GetGlossaryCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "GetGlossary", {})
     .n("DataZoneClient", "GetGlossaryCommand")
-    .sc(schemas_0.GetGlossary$)
+    .sc(GetGlossary$)
     .build() {
 }
 
-class GetGlossaryTermCommand extends client.Command
+class GetGlossaryTermCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "GetGlossaryTerm", {})
     .n("DataZoneClient", "GetGlossaryTermCommand")
-    .sc(schemas_0.GetGlossaryTerm$)
+    .sc(GetGlossaryTerm$)
     .build() {
 }
 
-class GetGroupProfileCommand extends client.Command
+class GetGroupProfileCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "GetGroupProfile", {})
     .n("DataZoneClient", "GetGroupProfileCommand")
-    .sc(schemas_0.GetGroupProfile$)
+    .sc(GetGroupProfile$)
     .build() {
 }
 
-class GetIamPortalLoginUrlCommand extends client.Command
+class GetIamPortalLoginUrlCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "GetIamPortalLoginUrl", {})
     .n("DataZoneClient", "GetIamPortalLoginUrlCommand")
-    .sc(schemas_0.GetIamPortalLoginUrl$)
+    .sc(GetIamPortalLoginUrl$)
     .build() {
 }
 
-class GetJobRunCommand extends client.Command
+class GetJobRunCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "GetJobRun", {})
     .n("DataZoneClient", "GetJobRunCommand")
-    .sc(schemas_0.GetJobRun$)
+    .sc(GetJobRun$)
     .build() {
 }
 
-class GetLineageEventCommand extends client.Command
+class GetLineageEventCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "GetLineageEvent", {})
     .n("DataZoneClient", "GetLineageEventCommand")
-    .sc(schemas_0.GetLineageEvent$)
+    .sc(GetLineageEvent$)
     .build() {
 }
 
-class GetLineageNodeCommand extends client.Command
+class GetLineageNodeCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "GetLineageNode", {})
     .n("DataZoneClient", "GetLineageNodeCommand")
-    .sc(schemas_0.GetLineageNode$)
+    .sc(GetLineageNode$)
     .build() {
 }
 
-class GetListingCommand extends client.Command
+class GetListingCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "GetListing", {})
     .n("DataZoneClient", "GetListingCommand")
-    .sc(schemas_0.GetListing$)
+    .sc(GetListing$)
     .build() {
 }
 
-class GetMetadataGenerationRunCommand extends client.Command
+class GetMetadataGenerationRunCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "GetMetadataGenerationRun", {})
     .n("DataZoneClient", "GetMetadataGenerationRunCommand")
-    .sc(schemas_0.GetMetadataGenerationRun$)
+    .sc(GetMetadataGenerationRun$)
     .build() {
 }
 
-class GetNotebookCommand extends client.Command
+class GetNotebookCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "GetNotebook", {})
     .n("DataZoneClient", "GetNotebookCommand")
-    .sc(schemas_0.GetNotebook$)
+    .sc(GetNotebook$)
     .build() {
 }
 
-class GetNotebookExportCommand extends client.Command
+class GetNotebookExportCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "GetNotebookExport", {})
     .n("DataZoneClient", "GetNotebookExportCommand")
-    .sc(schemas_0.GetNotebookExport$)
+    .sc(GetNotebookExport$)
     .build() {
 }
 
-class GetNotebookRunCommand extends client.Command
+class GetNotebookRunCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "GetNotebookRun", {})
     .n("DataZoneClient", "GetNotebookRunCommand")
-    .sc(schemas_0.GetNotebookRun$)
+    .sc(GetNotebookRun$)
     .build() {
 }
 
-class GetProjectCommand extends client.Command
+class GetProjectCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "GetProject", {})
     .n("DataZoneClient", "GetProjectCommand")
-    .sc(schemas_0.GetProject$)
+    .sc(GetProject$)
     .build() {
 }
 
-class GetProjectProfileCommand extends client.Command
+class GetProjectProfileCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "GetProjectProfile", {})
     .n("DataZoneClient", "GetProjectProfileCommand")
-    .sc(schemas_0.GetProjectProfile$)
+    .sc(GetProjectProfile$)
     .build() {
 }
 
-class GetRuleCommand extends client.Command
+class GetRuleCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "GetRule", {})
     .n("DataZoneClient", "GetRuleCommand")
-    .sc(schemas_0.GetRule$)
+    .sc(GetRule$)
     .build() {
 }
 
-class GetSubscriptionCommand extends client.Command
+class GetSubscriptionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "GetSubscription", {})
     .n("DataZoneClient", "GetSubscriptionCommand")
-    .sc(schemas_0.GetSubscription$)
+    .sc(GetSubscription$)
     .build() {
 }
 
-class GetSubscriptionGrantCommand extends client.Command
+class GetSubscriptionGrantCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "GetSubscriptionGrant", {})
     .n("DataZoneClient", "GetSubscriptionGrantCommand")
-    .sc(schemas_0.GetSubscriptionGrant$)
+    .sc(GetSubscriptionGrant$)
     .build() {
 }
 
-class GetSubscriptionRequestDetailsCommand extends client.Command
+class GetSubscriptionRequestDetailsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "GetSubscriptionRequestDetails", {})
     .n("DataZoneClient", "GetSubscriptionRequestDetailsCommand")
-    .sc(schemas_0.GetSubscriptionRequestDetails$)
+    .sc(GetSubscriptionRequestDetails$)
     .build() {
 }
 
-class GetSubscriptionTargetCommand extends client.Command
+class GetSubscriptionTargetCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "GetSubscriptionTarget", {})
     .n("DataZoneClient", "GetSubscriptionTargetCommand")
-    .sc(schemas_0.GetSubscriptionTarget$)
+    .sc(GetSubscriptionTarget$)
     .build() {
 }
 
-class GetTimeSeriesDataPointCommand extends client.Command
+class GetTimeSeriesDataPointCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "GetTimeSeriesDataPoint", {})
     .n("DataZoneClient", "GetTimeSeriesDataPointCommand")
-    .sc(schemas_0.GetTimeSeriesDataPoint$)
+    .sc(GetTimeSeriesDataPoint$)
     .build() {
 }
 
-class GetUserProfileCommand extends client.Command
+class GetUserProfileCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "GetUserProfile", {})
     .n("DataZoneClient", "GetUserProfileCommand")
-    .sc(schemas_0.GetUserProfile$)
+    .sc(GetUserProfile$)
     .build() {
 }
 
-class ListAccountPoolsCommand extends client.Command
+class ListAccountPoolsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "ListAccountPools", {})
     .n("DataZoneClient", "ListAccountPoolsCommand")
-    .sc(schemas_0.ListAccountPools$)
+    .sc(ListAccountPools$)
     .build() {
 }
 
-class ListAccountsInAccountPoolCommand extends client.Command
+class ListAccountsInAccountPoolCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "ListAccountsInAccountPool", {})
     .n("DataZoneClient", "ListAccountsInAccountPoolCommand")
-    .sc(schemas_0.ListAccountsInAccountPool$)
+    .sc(ListAccountsInAccountPool$)
     .build() {
 }
 
-class ListAssetFiltersCommand extends client.Command
+class ListAssetFiltersCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "ListAssetFilters", {})
     .n("DataZoneClient", "ListAssetFiltersCommand")
-    .sc(schemas_0.ListAssetFilters$)
+    .sc(ListAssetFilters$)
     .build() {
 }
 
-class ListAssetRevisionsCommand extends client.Command
+class ListAssetRevisionsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "ListAssetRevisions", {})
     .n("DataZoneClient", "ListAssetRevisionsCommand")
-    .sc(schemas_0.ListAssetRevisions$)
+    .sc(ListAssetRevisions$)
     .build() {
 }
 
-class ListConnectionsCommand extends client.Command
+class ListConnectionsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "ListConnections", {})
     .n("DataZoneClient", "ListConnectionsCommand")
-    .sc(schemas_0.ListConnections$)
+    .sc(ListConnections$)
     .build() {
 }
 
-class ListDataProductRevisionsCommand extends client.Command
+class ListDataProductRevisionsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "ListDataProductRevisions", {})
     .n("DataZoneClient", "ListDataProductRevisionsCommand")
-    .sc(schemas_0.ListDataProductRevisions$)
+    .sc(ListDataProductRevisions$)
     .build() {
 }
 
-class ListDataSourceRunActivitiesCommand extends client.Command
+class ListDataSourceRunActivitiesCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "ListDataSourceRunActivities", {})
     .n("DataZoneClient", "ListDataSourceRunActivitiesCommand")
-    .sc(schemas_0.ListDataSourceRunActivities$)
+    .sc(ListDataSourceRunActivities$)
     .build() {
 }
 
-class ListDataSourceRunsCommand extends client.Command
+class ListDataSourceRunsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "ListDataSourceRuns", {})
     .n("DataZoneClient", "ListDataSourceRunsCommand")
-    .sc(schemas_0.ListDataSourceRuns$)
+    .sc(ListDataSourceRuns$)
     .build() {
 }
 
-class ListDataSourcesCommand extends client.Command
+class ListDataSourcesCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "ListDataSources", {})
     .n("DataZoneClient", "ListDataSourcesCommand")
-    .sc(schemas_0.ListDataSources$)
+    .sc(ListDataSources$)
     .build() {
 }
 
-class ListDomainsCommand extends client.Command
+class ListDomainsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "ListDomains", {})
     .n("DataZoneClient", "ListDomainsCommand")
-    .sc(schemas_0.ListDomains$)
+    .sc(ListDomains$)
     .build() {
 }
 
-class ListDomainUnitsForParentCommand extends client.Command
+class ListDomainUnitsForParentCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "ListDomainUnitsForParent", {})
     .n("DataZoneClient", "ListDomainUnitsForParentCommand")
-    .sc(schemas_0.ListDomainUnitsForParent$)
+    .sc(ListDomainUnitsForParent$)
     .build() {
 }
 
-class ListEntityOwnersCommand extends client.Command
+class ListEntityOwnersCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "ListEntityOwners", {})
     .n("DataZoneClient", "ListEntityOwnersCommand")
-    .sc(schemas_0.ListEntityOwners$)
+    .sc(ListEntityOwners$)
     .build() {
 }
 
-class ListEnvironmentActionsCommand extends client.Command
+class ListEnvironmentActionsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "ListEnvironmentActions", {})
     .n("DataZoneClient", "ListEnvironmentActionsCommand")
-    .sc(schemas_0.ListEnvironmentActions$)
+    .sc(ListEnvironmentActions$)
     .build() {
 }
 
-class ListEnvironmentBlueprintConfigurationsCommand extends client.Command
+class ListEnvironmentBlueprintConfigurationsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "ListEnvironmentBlueprintConfigurations", {})
     .n("DataZoneClient", "ListEnvironmentBlueprintConfigurationsCommand")
-    .sc(schemas_0.ListEnvironmentBlueprintConfigurations$)
+    .sc(ListEnvironmentBlueprintConfigurations$)
     .build() {
 }
 
-class ListEnvironmentBlueprintsCommand extends client.Command
+class ListEnvironmentBlueprintsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "ListEnvironmentBlueprints", {})
     .n("DataZoneClient", "ListEnvironmentBlueprintsCommand")
-    .sc(schemas_0.ListEnvironmentBlueprints$)
+    .sc(ListEnvironmentBlueprints$)
     .build() {
 }
 
-class ListEnvironmentProfilesCommand extends client.Command
+class ListEnvironmentProfilesCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "ListEnvironmentProfiles", {})
     .n("DataZoneClient", "ListEnvironmentProfilesCommand")
-    .sc(schemas_0.ListEnvironmentProfiles$)
+    .sc(ListEnvironmentProfiles$)
     .build() {
 }
 
-class ListEnvironmentsCommand extends client.Command
+class ListEnvironmentsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "ListEnvironments", {})
     .n("DataZoneClient", "ListEnvironmentsCommand")
-    .sc(schemas_0.ListEnvironments$)
+    .sc(ListEnvironments$)
     .build() {
 }
 
-class ListJobRunsCommand extends client.Command
+class ListJobRunsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "ListJobRuns", {})
     .n("DataZoneClient", "ListJobRunsCommand")
-    .sc(schemas_0.ListJobRuns$)
+    .sc(ListJobRuns$)
     .build() {
 }
 
-class ListLineageEventsCommand extends client.Command
+class ListLineageEventsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "ListLineageEvents", {})
     .n("DataZoneClient", "ListLineageEventsCommand")
-    .sc(schemas_0.ListLineageEvents$)
+    .sc(ListLineageEvents$)
     .build() {
 }
 
-class ListLineageNodeHistoryCommand extends client.Command
+class ListLineageNodeHistoryCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "ListLineageNodeHistory", {})
     .n("DataZoneClient", "ListLineageNodeHistoryCommand")
-    .sc(schemas_0.ListLineageNodeHistory$)
+    .sc(ListLineageNodeHistory$)
     .build() {
 }
 
-class ListMetadataGenerationRunsCommand extends client.Command
+class ListMetadataGenerationRunsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "ListMetadataGenerationRuns", {})
     .n("DataZoneClient", "ListMetadataGenerationRunsCommand")
-    .sc(schemas_0.ListMetadataGenerationRuns$)
+    .sc(ListMetadataGenerationRuns$)
     .build() {
 }
 
-class ListNotebookRunsCommand extends client.Command
+class ListNotebookRunsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "ListNotebookRuns", {})
     .n("DataZoneClient", "ListNotebookRunsCommand")
-    .sc(schemas_0.ListNotebookRuns$)
+    .sc(ListNotebookRuns$)
     .build() {
 }
 
-class ListNotebooksCommand extends client.Command
+class ListNotebooksCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "ListNotebooks", {})
     .n("DataZoneClient", "ListNotebooksCommand")
-    .sc(schemas_0.ListNotebooks$)
+    .sc(ListNotebooks$)
     .build() {
 }
 
-class ListNotificationsCommand extends client.Command
+class ListNotificationsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "ListNotifications", {})
     .n("DataZoneClient", "ListNotificationsCommand")
-    .sc(schemas_0.ListNotifications$)
+    .sc(ListNotifications$)
     .build() {
 }
 
-class ListPolicyGrantsCommand extends client.Command
+class ListPolicyGrantsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "ListPolicyGrants", {})
     .n("DataZoneClient", "ListPolicyGrantsCommand")
-    .sc(schemas_0.ListPolicyGrants$)
+    .sc(ListPolicyGrants$)
     .build() {
 }
 
-class ListProjectMembershipsCommand extends client.Command
+class ListProjectMembershipsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "ListProjectMemberships", {})
     .n("DataZoneClient", "ListProjectMembershipsCommand")
-    .sc(schemas_0.ListProjectMemberships$)
+    .sc(ListProjectMemberships$)
     .build() {
 }
 
-class ListProjectProfilesCommand extends client.Command
+class ListProjectProfilesCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "ListProjectProfiles", {})
     .n("DataZoneClient", "ListProjectProfilesCommand")
-    .sc(schemas_0.ListProjectProfiles$)
+    .sc(ListProjectProfiles$)
     .build() {
 }
 
-class ListProjectsCommand extends client.Command
+class ListProjectsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "ListProjects", {})
     .n("DataZoneClient", "ListProjectsCommand")
-    .sc(schemas_0.ListProjects$)
+    .sc(ListProjects$)
     .build() {
 }
 
-class ListRulesCommand extends client.Command
+class ListRulesCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "ListRules", {})
     .n("DataZoneClient", "ListRulesCommand")
-    .sc(schemas_0.ListRules$)
+    .sc(ListRules$)
     .build() {
 }
 
-class ListSubscriptionGrantsCommand extends client.Command
+class ListSubscriptionGrantsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "ListSubscriptionGrants", {})
     .n("DataZoneClient", "ListSubscriptionGrantsCommand")
-    .sc(schemas_0.ListSubscriptionGrants$)
+    .sc(ListSubscriptionGrants$)
     .build() {
 }
 
-class ListSubscriptionRequestsCommand extends client.Command
+class ListSubscriptionRequestsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "ListSubscriptionRequests", {})
     .n("DataZoneClient", "ListSubscriptionRequestsCommand")
-    .sc(schemas_0.ListSubscriptionRequests$)
+    .sc(ListSubscriptionRequests$)
     .build() {
 }
 
-class ListSubscriptionsCommand extends client.Command
+class ListSubscriptionsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "ListSubscriptions", {})
     .n("DataZoneClient", "ListSubscriptionsCommand")
-    .sc(schemas_0.ListSubscriptions$)
+    .sc(ListSubscriptions$)
     .build() {
 }
 
-class ListSubscriptionTargetsCommand extends client.Command
+class ListSubscriptionTargetsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "ListSubscriptionTargets", {})
     .n("DataZoneClient", "ListSubscriptionTargetsCommand")
-    .sc(schemas_0.ListSubscriptionTargets$)
+    .sc(ListSubscriptionTargets$)
     .build() {
 }
 
-class ListTagsForResourceCommand extends client.Command
+class ListTagsForResourceCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "ListTagsForResource", {})
     .n("DataZoneClient", "ListTagsForResourceCommand")
-    .sc(schemas_0.ListTagsForResource$)
+    .sc(ListTagsForResource$)
     .build() {
 }
 
-class ListTimeSeriesDataPointsCommand extends client.Command
+class ListTimeSeriesDataPointsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "ListTimeSeriesDataPoints", {})
     .n("DataZoneClient", "ListTimeSeriesDataPointsCommand")
-    .sc(schemas_0.ListTimeSeriesDataPoints$)
+    .sc(ListTimeSeriesDataPoints$)
     .build() {
 }
 
-class PostLineageEventCommand extends client.Command
+class PostLineageEventCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "PostLineageEvent", {})
     .n("DataZoneClient", "PostLineageEventCommand")
-    .sc(schemas_0.PostLineageEvent$)
+    .sc(PostLineageEvent$)
     .build() {
 }
 
-class PostTimeSeriesDataPointsCommand extends client.Command
+class PostTimeSeriesDataPointsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "PostTimeSeriesDataPoints", {})
     .n("DataZoneClient", "PostTimeSeriesDataPointsCommand")
-    .sc(schemas_0.PostTimeSeriesDataPoints$)
+    .sc(PostTimeSeriesDataPoints$)
     .build() {
 }
 
-class PutDataExportConfigurationCommand extends client.Command
+class PutDataExportConfigurationCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "PutDataExportConfiguration", {})
     .n("DataZoneClient", "PutDataExportConfigurationCommand")
-    .sc(schemas_0.PutDataExportConfiguration$)
+    .sc(PutDataExportConfiguration$)
     .build() {
 }
 
-class PutEnvironmentBlueprintConfigurationCommand extends client.Command
+class PutEnvironmentBlueprintConfigurationCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "PutEnvironmentBlueprintConfiguration", {})
     .n("DataZoneClient", "PutEnvironmentBlueprintConfigurationCommand")
-    .sc(schemas_0.PutEnvironmentBlueprintConfiguration$)
+    .sc(PutEnvironmentBlueprintConfiguration$)
     .build() {
 }
 
-class QueryGraphCommand extends client.Command
+class QueryGraphCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "QueryGraph", {})
     .n("DataZoneClient", "QueryGraphCommand")
-    .sc(schemas_0.QueryGraph$)
+    .sc(QueryGraph$)
     .build() {
 }
 
-class RejectPredictionsCommand extends client.Command
+class RejectPredictionsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "RejectPredictions", {})
     .n("DataZoneClient", "RejectPredictionsCommand")
-    .sc(schemas_0.RejectPredictions$)
+    .sc(RejectPredictions$)
     .build() {
 }
 
-class RejectSubscriptionRequestCommand extends client.Command
+class RejectSubscriptionRequestCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "RejectSubscriptionRequest", {})
     .n("DataZoneClient", "RejectSubscriptionRequestCommand")
-    .sc(schemas_0.RejectSubscriptionRequest$)
+    .sc(RejectSubscriptionRequest$)
     .build() {
 }
 
-class RemoveEntityOwnerCommand extends client.Command
+class RemoveEntityOwnerCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "RemoveEntityOwner", {})
     .n("DataZoneClient", "RemoveEntityOwnerCommand")
-    .sc(schemas_0.RemoveEntityOwner$)
+    .sc(RemoveEntityOwner$)
     .build() {
 }
 
-class RemovePolicyGrantCommand extends client.Command
+class RemovePolicyGrantCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "RemovePolicyGrant", {})
     .n("DataZoneClient", "RemovePolicyGrantCommand")
-    .sc(schemas_0.RemovePolicyGrant$)
+    .sc(RemovePolicyGrant$)
     .build() {
 }
 
-class RevokeSubscriptionCommand extends client.Command
+class RevokeSubscriptionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "RevokeSubscription", {})
     .n("DataZoneClient", "RevokeSubscriptionCommand")
-    .sc(schemas_0.RevokeSubscription$)
+    .sc(RevokeSubscription$)
     .build() {
 }
 
-class SearchCommand extends client.Command
+class SearchCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "Search", {})
     .n("DataZoneClient", "SearchCommand")
-    .sc(schemas_0.Search$)
+    .sc(Search$)
     .build() {
 }
 
-class SearchGroupProfilesCommand extends client.Command
+class SearchGroupProfilesCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "SearchGroupProfiles", {})
     .n("DataZoneClient", "SearchGroupProfilesCommand")
-    .sc(schemas_0.SearchGroupProfiles$)
+    .sc(SearchGroupProfiles$)
     .build() {
 }
 
-class SearchListingsCommand extends client.Command
+class SearchListingsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "SearchListings", {})
     .n("DataZoneClient", "SearchListingsCommand")
-    .sc(schemas_0.SearchListings$)
+    .sc(SearchListings$)
     .build() {
 }
 
-class SearchTypesCommand extends client.Command
+class SearchTypesCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "SearchTypes", {})
     .n("DataZoneClient", "SearchTypesCommand")
-    .sc(schemas_0.SearchTypes$)
+    .sc(SearchTypes$)
     .build() {
 }
 
-class SearchUserProfilesCommand extends client.Command
+class SearchUserProfilesCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "SearchUserProfiles", {})
     .n("DataZoneClient", "SearchUserProfilesCommand")
-    .sc(schemas_0.SearchUserProfiles$)
+    .sc(SearchUserProfiles$)
     .build() {
 }
 
-class StartDataSourceRunCommand extends client.Command
+class StartDataSourceRunCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "StartDataSourceRun", {})
     .n("DataZoneClient", "StartDataSourceRunCommand")
-    .sc(schemas_0.StartDataSourceRun$)
+    .sc(StartDataSourceRun$)
     .build() {
 }
 
-class StartMetadataGenerationRunCommand extends client.Command
+class StartMetadataGenerationRunCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "StartMetadataGenerationRun", {})
     .n("DataZoneClient", "StartMetadataGenerationRunCommand")
-    .sc(schemas_0.StartMetadataGenerationRun$)
+    .sc(StartMetadataGenerationRun$)
     .build() {
 }
 
-class StartNotebookExportCommand extends client.Command
+class StartNotebookExportCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "StartNotebookExport", {})
     .n("DataZoneClient", "StartNotebookExportCommand")
-    .sc(schemas_0.StartNotebookExport$)
+    .sc(StartNotebookExport$)
     .build() {
 }
 
-class StartNotebookImportCommand extends client.Command
+class StartNotebookImportCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "StartNotebookImport", {})
     .n("DataZoneClient", "StartNotebookImportCommand")
-    .sc(schemas_0.StartNotebookImport$)
+    .sc(StartNotebookImport$)
     .build() {
 }
 
-class StartNotebookRunCommand extends client.Command
+class StartNotebookRunCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "StartNotebookRun", {})
     .n("DataZoneClient", "StartNotebookRunCommand")
-    .sc(schemas_0.StartNotebookRun$)
+    .sc(StartNotebookRun$)
     .build() {
 }
 
-class StopNotebookRunCommand extends client.Command
+class StopNotebookRunCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "StopNotebookRun", {})
     .n("DataZoneClient", "StopNotebookRunCommand")
-    .sc(schemas_0.StopNotebookRun$)
+    .sc(StopNotebookRun$)
     .build() {
 }
 
-class TagResourceCommand extends client.Command
+class TagResourceCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "TagResource", {})
     .n("DataZoneClient", "TagResourceCommand")
-    .sc(schemas_0.TagResource$)
+    .sc(TagResource$)
     .build() {
 }
 
-class UntagResourceCommand extends client.Command
+class UntagResourceCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "UntagResource", {})
     .n("DataZoneClient", "UntagResourceCommand")
-    .sc(schemas_0.UntagResource$)
+    .sc(UntagResource$)
     .build() {
 }
 
-class UpdateAccountPoolCommand extends client.Command
+class UpdateAccountPoolCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "UpdateAccountPool", {})
     .n("DataZoneClient", "UpdateAccountPoolCommand")
-    .sc(schemas_0.UpdateAccountPool$)
+    .sc(UpdateAccountPool$)
     .build() {
 }
 
-class UpdateAssetFilterCommand extends client.Command
+class UpdateAssetFilterCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "UpdateAssetFilter", {})
     .n("DataZoneClient", "UpdateAssetFilterCommand")
-    .sc(schemas_0.UpdateAssetFilter$)
+    .sc(UpdateAssetFilter$)
     .build() {
 }
 
-class UpdateConnectionCommand extends client.Command
+class UpdateConnectionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "UpdateConnection", {})
     .n("DataZoneClient", "UpdateConnectionCommand")
-    .sc(schemas_0.UpdateConnection$)
+    .sc(UpdateConnection$)
     .build() {
 }
 
-class UpdateDataSourceCommand extends client.Command
+class UpdateDataSourceCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "UpdateDataSource", {})
     .n("DataZoneClient", "UpdateDataSourceCommand")
-    .sc(schemas_0.UpdateDataSource$)
+    .sc(UpdateDataSource$)
     .build() {
 }
 
-class UpdateDomainCommand extends client.Command
+class UpdateDomainCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "UpdateDomain", {})
     .n("DataZoneClient", "UpdateDomainCommand")
-    .sc(schemas_0.UpdateDomain$)
+    .sc(UpdateDomain$)
     .build() {
 }
 
-class UpdateDomainUnitCommand extends client.Command
+class UpdateDomainUnitCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "UpdateDomainUnit", {})
     .n("DataZoneClient", "UpdateDomainUnitCommand")
-    .sc(schemas_0.UpdateDomainUnit$)
+    .sc(UpdateDomainUnit$)
     .build() {
 }
 
-class UpdateEnvironmentActionCommand extends client.Command
+class UpdateEnvironmentActionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "UpdateEnvironmentAction", {})
     .n("DataZoneClient", "UpdateEnvironmentActionCommand")
-    .sc(schemas_0.UpdateEnvironmentAction$)
+    .sc(UpdateEnvironmentAction$)
     .build() {
 }
 
-class UpdateEnvironmentBlueprintCommand extends client.Command
+class UpdateEnvironmentBlueprintCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "UpdateEnvironmentBlueprint", {})
     .n("DataZoneClient", "UpdateEnvironmentBlueprintCommand")
-    .sc(schemas_0.UpdateEnvironmentBlueprint$)
+    .sc(UpdateEnvironmentBlueprint$)
     .build() {
 }
 
-class UpdateEnvironmentCommand extends client.Command
+class UpdateEnvironmentCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "UpdateEnvironment", {})
     .n("DataZoneClient", "UpdateEnvironmentCommand")
-    .sc(schemas_0.UpdateEnvironment$)
+    .sc(UpdateEnvironment$)
     .build() {
 }
 
-class UpdateEnvironmentProfileCommand extends client.Command
+class UpdateEnvironmentProfileCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "UpdateEnvironmentProfile", {})
     .n("DataZoneClient", "UpdateEnvironmentProfileCommand")
-    .sc(schemas_0.UpdateEnvironmentProfile$)
+    .sc(UpdateEnvironmentProfile$)
     .build() {
 }
 
-class UpdateGlossaryCommand extends client.Command
+class UpdateGlossaryCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "UpdateGlossary", {})
     .n("DataZoneClient", "UpdateGlossaryCommand")
-    .sc(schemas_0.UpdateGlossary$)
+    .sc(UpdateGlossary$)
     .build() {
 }
 
-class UpdateGlossaryTermCommand extends client.Command
+class UpdateGlossaryTermCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "UpdateGlossaryTerm", {})
     .n("DataZoneClient", "UpdateGlossaryTermCommand")
-    .sc(schemas_0.UpdateGlossaryTerm$)
+    .sc(UpdateGlossaryTerm$)
     .build() {
 }
 
-class UpdateGroupProfileCommand extends client.Command
+class UpdateGroupProfileCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "UpdateGroupProfile", {})
     .n("DataZoneClient", "UpdateGroupProfileCommand")
-    .sc(schemas_0.UpdateGroupProfile$)
+    .sc(UpdateGroupProfile$)
     .build() {
 }
 
-class UpdateNotebookCommand extends client.Command
+class UpdateNotebookCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "UpdateNotebook", {})
     .n("DataZoneClient", "UpdateNotebookCommand")
-    .sc(schemas_0.UpdateNotebook$)
+    .sc(UpdateNotebook$)
     .build() {
 }
 
-class UpdateProjectCommand extends client.Command
+class UpdateProjectCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "UpdateProject", {})
     .n("DataZoneClient", "UpdateProjectCommand")
-    .sc(schemas_0.UpdateProject$)
+    .sc(UpdateProject$)
     .build() {
 }
 
-class UpdateProjectProfileCommand extends client.Command
+class UpdateProjectProfileCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "UpdateProjectProfile", {})
     .n("DataZoneClient", "UpdateProjectProfileCommand")
-    .sc(schemas_0.UpdateProjectProfile$)
+    .sc(UpdateProjectProfile$)
     .build() {
 }
 
-class UpdateRootDomainUnitOwnerCommand extends client.Command
+class UpdateRootDomainUnitOwnerCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "UpdateRootDomainUnitOwner", {})
     .n("DataZoneClient", "UpdateRootDomainUnitOwnerCommand")
-    .sc(schemas_0.UpdateRootDomainUnitOwner$)
+    .sc(UpdateRootDomainUnitOwner$)
     .build() {
 }
 
-class UpdateRuleCommand extends client.Command
+class UpdateRuleCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "UpdateRule", {})
     .n("DataZoneClient", "UpdateRuleCommand")
-    .sc(schemas_0.UpdateRule$)
+    .sc(UpdateRule$)
     .build() {
 }
 
-class UpdateSubscriptionGrantStatusCommand extends client.Command
+class UpdateSubscriptionGrantStatusCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "UpdateSubscriptionGrantStatus", {})
     .n("DataZoneClient", "UpdateSubscriptionGrantStatusCommand")
-    .sc(schemas_0.UpdateSubscriptionGrantStatus$)
+    .sc(UpdateSubscriptionGrantStatus$)
     .build() {
 }
 
-class UpdateSubscriptionRequestCommand extends client.Command
+class UpdateSubscriptionRequestCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "UpdateSubscriptionRequest", {})
     .n("DataZoneClient", "UpdateSubscriptionRequestCommand")
-    .sc(schemas_0.UpdateSubscriptionRequest$)
+    .sc(UpdateSubscriptionRequest$)
     .build() {
 }
 
-class UpdateSubscriptionTargetCommand extends client.Command
+class UpdateSubscriptionTargetCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "UpdateSubscriptionTarget", {})
     .n("DataZoneClient", "UpdateSubscriptionTargetCommand")
-    .sc(schemas_0.UpdateSubscriptionTarget$)
+    .sc(UpdateSubscriptionTarget$)
     .build() {
 }
 
-class UpdateUserProfileCommand extends client.Command
+class UpdateUserProfileCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DataZone", "UpdateUserProfile", {})
     .n("DataZoneClient", "UpdateUserProfileCommand")
-    .sc(schemas_0.UpdateUserProfile$)
+    .sc(UpdateUserProfile$)
     .build() {
 }
 
-const paginateListAccountPools = core.createPaginator(DataZoneClient, ListAccountPoolsCommand, "nextToken", "nextToken", "maxResults");
+const paginateListAccountPools = createPaginator(DataZoneClient, ListAccountPoolsCommand, "nextToken", "nextToken", "maxResults");
 
-const paginateListAccountsInAccountPool = core.createPaginator(DataZoneClient, ListAccountsInAccountPoolCommand, "nextToken", "nextToken", "maxResults");
+const paginateListAccountsInAccountPool = createPaginator(DataZoneClient, ListAccountsInAccountPoolCommand, "nextToken", "nextToken", "maxResults");
 
-const paginateListAssetFilters = core.createPaginator(DataZoneClient, ListAssetFiltersCommand, "nextToken", "nextToken", "maxResults");
+const paginateListAssetFilters = createPaginator(DataZoneClient, ListAssetFiltersCommand, "nextToken", "nextToken", "maxResults");
 
-const paginateListAssetRevisions = core.createPaginator(DataZoneClient, ListAssetRevisionsCommand, "nextToken", "nextToken", "maxResults");
+const paginateListAssetRevisions = createPaginator(DataZoneClient, ListAssetRevisionsCommand, "nextToken", "nextToken", "maxResults");
 
-const paginateListConnections = core.createPaginator(DataZoneClient, ListConnectionsCommand, "nextToken", "nextToken", "maxResults");
+const paginateListConnections = createPaginator(DataZoneClient, ListConnectionsCommand, "nextToken", "nextToken", "maxResults");
 
-const paginateListDataProductRevisions = core.createPaginator(DataZoneClient, ListDataProductRevisionsCommand, "nextToken", "nextToken", "maxResults");
+const paginateListDataProductRevisions = createPaginator(DataZoneClient, ListDataProductRevisionsCommand, "nextToken", "nextToken", "maxResults");
 
-const paginateListDataSourceRunActivities = core.createPaginator(DataZoneClient, ListDataSourceRunActivitiesCommand, "nextToken", "nextToken", "maxResults");
+const paginateListDataSourceRunActivities = createPaginator(DataZoneClient, ListDataSourceRunActivitiesCommand, "nextToken", "nextToken", "maxResults");
 
-const paginateListDataSourceRuns = core.createPaginator(DataZoneClient, ListDataSourceRunsCommand, "nextToken", "nextToken", "maxResults");
+const paginateListDataSourceRuns = createPaginator(DataZoneClient, ListDataSourceRunsCommand, "nextToken", "nextToken", "maxResults");
 
-const paginateListDataSources = core.createPaginator(DataZoneClient, ListDataSourcesCommand, "nextToken", "nextToken", "maxResults");
+const paginateListDataSources = createPaginator(DataZoneClient, ListDataSourcesCommand, "nextToken", "nextToken", "maxResults");
 
-const paginateListDomains = core.createPaginator(DataZoneClient, ListDomainsCommand, "nextToken", "nextToken", "maxResults");
+const paginateListDomains = createPaginator(DataZoneClient, ListDomainsCommand, "nextToken", "nextToken", "maxResults");
 
-const paginateListDomainUnitsForParent = core.createPaginator(DataZoneClient, ListDomainUnitsForParentCommand, "nextToken", "nextToken", "maxResults");
+const paginateListDomainUnitsForParent = createPaginator(DataZoneClient, ListDomainUnitsForParentCommand, "nextToken", "nextToken", "maxResults");
 
-const paginateListEntityOwners = core.createPaginator(DataZoneClient, ListEntityOwnersCommand, "nextToken", "nextToken", "maxResults");
+const paginateListEntityOwners = createPaginator(DataZoneClient, ListEntityOwnersCommand, "nextToken", "nextToken", "maxResults");
 
-const paginateListEnvironmentActions = core.createPaginator(DataZoneClient, ListEnvironmentActionsCommand, "nextToken", "nextToken", "maxResults");
+const paginateListEnvironmentActions = createPaginator(DataZoneClient, ListEnvironmentActionsCommand, "nextToken", "nextToken", "maxResults");
 
-const paginateListEnvironmentBlueprintConfigurations = core.createPaginator(DataZoneClient, ListEnvironmentBlueprintConfigurationsCommand, "nextToken", "nextToken", "maxResults");
+const paginateListEnvironmentBlueprintConfigurations = createPaginator(DataZoneClient, ListEnvironmentBlueprintConfigurationsCommand, "nextToken", "nextToken", "maxResults");
 
-const paginateListEnvironmentBlueprints = core.createPaginator(DataZoneClient, ListEnvironmentBlueprintsCommand, "nextToken", "nextToken", "maxResults");
+const paginateListEnvironmentBlueprints = createPaginator(DataZoneClient, ListEnvironmentBlueprintsCommand, "nextToken", "nextToken", "maxResults");
 
-const paginateListEnvironmentProfiles = core.createPaginator(DataZoneClient, ListEnvironmentProfilesCommand, "nextToken", "nextToken", "maxResults");
+const paginateListEnvironmentProfiles = createPaginator(DataZoneClient, ListEnvironmentProfilesCommand, "nextToken", "nextToken", "maxResults");
 
-const paginateListEnvironments = core.createPaginator(DataZoneClient, ListEnvironmentsCommand, "nextToken", "nextToken", "maxResults");
+const paginateListEnvironments = createPaginator(DataZoneClient, ListEnvironmentsCommand, "nextToken", "nextToken", "maxResults");
 
-const paginateListJobRuns = core.createPaginator(DataZoneClient, ListJobRunsCommand, "nextToken", "nextToken", "maxResults");
+const paginateListJobRuns = createPaginator(DataZoneClient, ListJobRunsCommand, "nextToken", "nextToken", "maxResults");
 
-const paginateListLineageEvents = core.createPaginator(DataZoneClient, ListLineageEventsCommand, "nextToken", "nextToken", "maxResults");
+const paginateListLineageEvents = createPaginator(DataZoneClient, ListLineageEventsCommand, "nextToken", "nextToken", "maxResults");
 
-const paginateListLineageNodeHistory = core.createPaginator(DataZoneClient, ListLineageNodeHistoryCommand, "nextToken", "nextToken", "maxResults");
+const paginateListLineageNodeHistory = createPaginator(DataZoneClient, ListLineageNodeHistoryCommand, "nextToken", "nextToken", "maxResults");
 
-const paginateListMetadataGenerationRuns = core.createPaginator(DataZoneClient, ListMetadataGenerationRunsCommand, "nextToken", "nextToken", "maxResults");
+const paginateListMetadataGenerationRuns = createPaginator(DataZoneClient, ListMetadataGenerationRunsCommand, "nextToken", "nextToken", "maxResults");
 
-const paginateListNotebookRuns = core.createPaginator(DataZoneClient, ListNotebookRunsCommand, "nextToken", "nextToken", "maxResults");
+const paginateListNotebookRuns = createPaginator(DataZoneClient, ListNotebookRunsCommand, "nextToken", "nextToken", "maxResults");
 
-const paginateListNotebooks = core.createPaginator(DataZoneClient, ListNotebooksCommand, "nextToken", "nextToken", "maxResults");
+const paginateListNotebooks = createPaginator(DataZoneClient, ListNotebooksCommand, "nextToken", "nextToken", "maxResults");
 
-const paginateListNotifications = core.createPaginator(DataZoneClient, ListNotificationsCommand, "nextToken", "nextToken", "maxResults");
+const paginateListNotifications = createPaginator(DataZoneClient, ListNotificationsCommand, "nextToken", "nextToken", "maxResults");
 
-const paginateListPolicyGrants = core.createPaginator(DataZoneClient, ListPolicyGrantsCommand, "nextToken", "nextToken", "maxResults");
+const paginateListPolicyGrants = createPaginator(DataZoneClient, ListPolicyGrantsCommand, "nextToken", "nextToken", "maxResults");
 
-const paginateListProjectMemberships = core.createPaginator(DataZoneClient, ListProjectMembershipsCommand, "nextToken", "nextToken", "maxResults");
+const paginateListProjectMemberships = createPaginator(DataZoneClient, ListProjectMembershipsCommand, "nextToken", "nextToken", "maxResults");
 
-const paginateListProjectProfiles = core.createPaginator(DataZoneClient, ListProjectProfilesCommand, "nextToken", "nextToken", "maxResults");
+const paginateListProjectProfiles = createPaginator(DataZoneClient, ListProjectProfilesCommand, "nextToken", "nextToken", "maxResults");
 
-const paginateListProjects = core.createPaginator(DataZoneClient, ListProjectsCommand, "nextToken", "nextToken", "maxResults");
+const paginateListProjects = createPaginator(DataZoneClient, ListProjectsCommand, "nextToken", "nextToken", "maxResults");
 
-const paginateListRules = core.createPaginator(DataZoneClient, ListRulesCommand, "nextToken", "nextToken", "maxResults");
+const paginateListRules = createPaginator(DataZoneClient, ListRulesCommand, "nextToken", "nextToken", "maxResults");
 
-const paginateListSubscriptionGrants = core.createPaginator(DataZoneClient, ListSubscriptionGrantsCommand, "nextToken", "nextToken", "maxResults");
+const paginateListSubscriptionGrants = createPaginator(DataZoneClient, ListSubscriptionGrantsCommand, "nextToken", "nextToken", "maxResults");
 
-const paginateListSubscriptionRequests = core.createPaginator(DataZoneClient, ListSubscriptionRequestsCommand, "nextToken", "nextToken", "maxResults");
+const paginateListSubscriptionRequests = createPaginator(DataZoneClient, ListSubscriptionRequestsCommand, "nextToken", "nextToken", "maxResults");
 
-const paginateListSubscriptions = core.createPaginator(DataZoneClient, ListSubscriptionsCommand, "nextToken", "nextToken", "maxResults");
+const paginateListSubscriptions = createPaginator(DataZoneClient, ListSubscriptionsCommand, "nextToken", "nextToken", "maxResults");
 
-const paginateListSubscriptionTargets = core.createPaginator(DataZoneClient, ListSubscriptionTargetsCommand, "nextToken", "nextToken", "maxResults");
+const paginateListSubscriptionTargets = createPaginator(DataZoneClient, ListSubscriptionTargetsCommand, "nextToken", "nextToken", "maxResults");
 
-const paginateListTimeSeriesDataPoints = core.createPaginator(DataZoneClient, ListTimeSeriesDataPointsCommand, "nextToken", "nextToken", "maxResults");
+const paginateListTimeSeriesDataPoints = createPaginator(DataZoneClient, ListTimeSeriesDataPointsCommand, "nextToken", "nextToken", "maxResults");
 
-const paginateQueryGraph = core.createPaginator(DataZoneClient, QueryGraphCommand, "nextToken", "nextToken", "maxResults");
+const paginateQueryGraph = createPaginator(DataZoneClient, QueryGraphCommand, "nextToken", "nextToken", "maxResults");
 
-const paginateSearchGroupProfiles = core.createPaginator(DataZoneClient, SearchGroupProfilesCommand, "nextToken", "nextToken", "maxResults");
+const paginateSearchGroupProfiles = createPaginator(DataZoneClient, SearchGroupProfilesCommand, "nextToken", "nextToken", "maxResults");
 
-const paginateSearchListings = core.createPaginator(DataZoneClient, SearchListingsCommand, "nextToken", "nextToken", "maxResults");
+const paginateSearchListings = createPaginator(DataZoneClient, SearchListingsCommand, "nextToken", "nextToken", "maxResults");
 
-const paginateSearch = core.createPaginator(DataZoneClient, SearchCommand, "nextToken", "nextToken", "maxResults");
+const paginateSearch = createPaginator(DataZoneClient, SearchCommand, "nextToken", "nextToken", "maxResults");
 
-const paginateSearchTypes = core.createPaginator(DataZoneClient, SearchTypesCommand, "nextToken", "nextToken", "maxResults");
+const paginateSearchTypes = createPaginator(DataZoneClient, SearchTypesCommand, "nextToken", "nextToken", "maxResults");
 
-const paginateSearchUserProfiles = core.createPaginator(DataZoneClient, SearchUserProfilesCommand, "nextToken", "nextToken", "maxResults");
+const paginateSearchUserProfiles = createPaginator(DataZoneClient, SearchUserProfilesCommand, "nextToken", "nextToken", "maxResults");
 
 const commands = {
     AcceptPredictionsCommand,
@@ -2500,6 +2515,7 @@ const commands = {
     DeleteFormTypeCommand,
     DeleteGlossaryCommand,
     DeleteGlossaryTermCommand,
+    DeleteLineageEventCommand,
     DeleteListingCommand,
     DeleteNotebookCommand,
     DeleteProjectCommand,
@@ -2676,7 +2692,7 @@ const paginators = {
 };
 class DataZone extends DataZoneClient {
 }
-client.createAggregatedClient(commands, DataZone, { paginators });
+createAggregatedClient(commands, DataZone, { paginators });
 
 const AcceptRuleBehavior = {
     ALL: "ALL",
@@ -3314,9 +3330,6 @@ const UserSearchType = {
     SSO_USER: "SSO_USER",
 };
 
-exports.$Command = client.Command;
-exports.__Client = client.Client;
-exports.DataZoneServiceException = DataZoneServiceException.DataZoneServiceException;
 exports.AcceptPredictionsCommand = AcceptPredictionsCommand;
 exports.AcceptRuleBehavior = AcceptRuleBehavior;
 exports.AcceptSubscriptionRequestCommand = AcceptSubscriptionRequestCommand;
@@ -3395,6 +3408,7 @@ exports.DeleteEnvironmentProfileCommand = DeleteEnvironmentProfileCommand;
 exports.DeleteFormTypeCommand = DeleteFormTypeCommand;
 exports.DeleteGlossaryCommand = DeleteGlossaryCommand;
 exports.DeleteGlossaryTermCommand = DeleteGlossaryTermCommand;
+exports.DeleteLineageEventCommand = DeleteLineageEventCommand;
 exports.DeleteListingCommand = DeleteListingCommand;
 exports.DeleteNotebookCommand = DeleteNotebookCommand;
 exports.DeleteProjectCommand = DeleteProjectCommand;
@@ -3651,23 +3665,3 @@ exports.paginateSearchGroupProfiles = paginateSearchGroupProfiles;
 exports.paginateSearchListings = paginateSearchListings;
 exports.paginateSearchTypes = paginateSearchTypes;
 exports.paginateSearchUserProfiles = paginateSearchUserProfiles;
-Object.prototype.hasOwnProperty.call(schemas_0, '__proto__') &&
-    !Object.prototype.hasOwnProperty.call(exports, '__proto__') &&
-    Object.defineProperty(exports, '__proto__', {
-        enumerable: true,
-        value: schemas_0['__proto__']
-    });
-
-Object.keys(schemas_0).forEach(function (k) {
-    if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) exports[k] = schemas_0[k];
-});
-Object.prototype.hasOwnProperty.call(errors, '__proto__') &&
-    !Object.prototype.hasOwnProperty.call(exports, '__proto__') &&
-    Object.defineProperty(exports, '__proto__', {
-        enumerable: true,
-        value: errors['__proto__']
-    });
-
-Object.keys(errors).forEach(function (k) {
-    if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) exports[k] = errors[k];
-});