@aws-sdk/client-appflow 3.928.0 → 3.930.0

package/dist-cjs/index.js

@@ -6,6 +6,7 @@ var middlewareRecursionDetection = require('@aws-sdk/middleware-recursion-detect
 var middlewareUserAgent = require('@aws-sdk/middleware-user-agent');
 var configResolver = require('@smithy/config-resolver');
 var core = require('@smithy/core');
+var schema = require('@smithy/core/schema');
 var middlewareContentLength = require('@smithy/middleware-content-length');
 var middlewareEndpoint = require('@smithy/middleware-endpoint');
 var middlewareRetry = require('@smithy/middleware-retry');
@@ -14,9 +15,6 @@ var httpAuthSchemeProvider = require('./auth/httpAuthSchemeProvider');
 var runtimeConfig = require('./runtimeConfig');
 var regionConfigResolver = require('@aws-sdk/region-config-resolver');
 var protocolHttp = require('@smithy/protocol-http');
-var middlewareSerde = require('@smithy/middleware-serde');
-var core$1 = require('@aws-sdk/core');
-var uuid = require('@smithy/uuid');
 
 const resolveClientEndpointParameters = (options) => {
     return Object.assign(options, {
@@ -92,6 +90,7 @@ class AppflowClient extends smithyClient.Client {
         const _config_7 = httpAuthSchemeProvider.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(middlewareUserAgent.getUserAgentPlugin(this.config));
         this.middlewareStack.use(middlewareRetry.getRetryPlugin(this.config));
         this.middlewareStack.use(middlewareContentLength.getContentLengthPlugin(this.config));
@@ -111,14 +110,14 @@ class AppflowClient extends smithyClient.Client {
     }
 }
 
-class AppflowServiceException extends smithyClient.ServiceException {
+let AppflowServiceException$1 = class AppflowServiceException extends smithyClient.ServiceException {
     constructor(options) {
         super(options);
         Object.setPrototypeOf(this, AppflowServiceException.prototype);
     }
-}
+};
 
-class AccessDeniedException extends AppflowServiceException {
+let AccessDeniedException$1 = class AccessDeniedException extends AppflowServiceException$1 {
     name = "AccessDeniedException";
     $fault = "client";
     constructor(opts) {
@@ -129,7 +128,7 @@ class AccessDeniedException extends AppflowServiceException {
         });
         Object.setPrototypeOf(this, AccessDeniedException.prototype);
     }
-}
+};
 const AggregationType = {
     NONE: "None",
     SINGLE_FILE: "SingleFile",
@@ -152,7 +151,7 @@ const AuthenticationType = {
     CUSTOM: "CUSTOM",
     OAUTH2: "OAUTH2",
 };
-class InternalServerException extends AppflowServiceException {
+let InternalServerException$1 = class InternalServerException extends AppflowServiceException$1 {
     name = "InternalServerException";
     $fault = "server";
     constructor(opts) {
@@ -163,8 +162,8 @@ class InternalServerException extends AppflowServiceException {
         });
         Object.setPrototypeOf(this, InternalServerException.prototype);
     }
-}
-class ResourceNotFoundException extends AppflowServiceException {
+};
+let ResourceNotFoundException$1 = class ResourceNotFoundException extends AppflowServiceException$1 {
     name = "ResourceNotFoundException";
     $fault = "client";
     constructor(opts) {
@@ -175,8 +174,8 @@ class ResourceNotFoundException extends AppflowServiceException {
         });
         Object.setPrototypeOf(this, ResourceNotFoundException.prototype);
     }
-}
-class ThrottlingException extends AppflowServiceException {
+};
+let ThrottlingException$1 = class ThrottlingException extends AppflowServiceException$1 {
     name = "ThrottlingException";
     $fault = "client";
     constructor(opts) {
@@ -187,8 +186,8 @@ class ThrottlingException extends AppflowServiceException {
         });
         Object.setPrototypeOf(this, ThrottlingException.prototype);
     }
-}
-class ValidationException extends AppflowServiceException {
+};
+let ValidationException$1 = class ValidationException extends AppflowServiceException$1 {
     name = "ValidationException";
     $fault = "client";
     constructor(opts) {
@@ -199,11 +198,11 @@ class ValidationException extends AppflowServiceException {
         });
         Object.setPrototypeOf(this, ValidationException.prototype);
     }
-}
+};
 const CatalogType = {
     GLUE: "GLUE",
 };
-class ConflictException extends AppflowServiceException {
+let ConflictException$1 = class ConflictException extends AppflowServiceException$1 {
     name = "ConflictException";
     $fault = "client";
     constructor(opts) {
@@ -214,12 +213,12 @@ class ConflictException extends AppflowServiceException {
         });
         Object.setPrototypeOf(this, ConflictException.prototype);
     }
-}
+};
 const ConnectionMode = {
     PRIVATE: "Private",
     PUBLIC: "Public",
 };
-class ConnectorAuthenticationException extends AppflowServiceException {
+let ConnectorAuthenticationException$1 = class ConnectorAuthenticationException extends AppflowServiceException$1 {
     name = "ConnectorAuthenticationException";
     $fault = "client";
     constructor(opts) {
@@ -230,7 +229,7 @@ class ConnectorAuthenticationException extends AppflowServiceException {
         });
         Object.setPrototypeOf(this, ConnectorAuthenticationException.prototype);
     }
-}
+};
 const SalesforceDataTransferApi = {
     AUTOMATIC: "AUTOMATIC",
     BULKV2: "BULKV2",
@@ -623,7 +622,7 @@ const PrivateConnectionProvisioningStatus = {
     FAILED: "FAILED",
     PENDING: "PENDING",
 };
-class ConnectorServerException extends AppflowServiceException {
+let ConnectorServerException$1 = class ConnectorServerException extends AppflowServiceException$1 {
     name = "ConnectorServerException";
     $fault = "client";
     constructor(opts) {
@@ -634,8 +633,8 @@ class ConnectorServerException extends AppflowServiceException {
         });
         Object.setPrototypeOf(this, ConnectorServerException.prototype);
     }
-}
-class ServiceQuotaExceededException extends AppflowServiceException {
+};
+let ServiceQuotaExceededException$1 = class ServiceQuotaExceededException extends AppflowServiceException$1 {
     name = "ServiceQuotaExceededException";
     $fault = "client";
     constructor(opts) {
@@ -646,7 +645,7 @@ class ServiceQuotaExceededException extends AppflowServiceException {
         });
         Object.setPrototypeOf(this, ServiceQuotaExceededException.prototype);
     }
-}
+};
 const FileType = {
     CSV: "CSV",
     JSON: "JSON",
@@ -722,7 +721,7 @@ const ExecutionStatus = {
     INPROGRESS: "InProgress",
     SUCCESSFUL: "Successful",
 };
-class UnsupportedOperationException extends AppflowServiceException {
+let UnsupportedOperationException$1 = class UnsupportedOperationException extends AppflowServiceException$1 {
     name = "UnsupportedOperationException";
     $fault = "client";
     constructor(opts) {
@@ -733,1322 +732,2037 @@ class UnsupportedOperationException extends AppflowServiceException {
         });
         Object.setPrototypeOf(this, UnsupportedOperationException.prototype);
     }
-}
-const AmplitudeConnectorProfileCredentialsFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.apiKey && { apiKey: smithyClient.SENSITIVE_STRING }),
-    ...(obj.secretKey && { secretKey: smithyClient.SENSITIVE_STRING }),
-});
-const ApiKeyCredentialsFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.apiKey && { apiKey: smithyClient.SENSITIVE_STRING }),
-    ...(obj.apiSecretKey && { apiSecretKey: smithyClient.SENSITIVE_STRING }),
-});
-const BasicAuthCredentialsFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.password && { password: smithyClient.SENSITIVE_STRING }),
-});
-const CustomAuthCredentialsFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.credentialsMap && { credentialsMap: smithyClient.SENSITIVE_STRING }),
-});
-const OAuth2CredentialsFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.clientSecret && { clientSecret: smithyClient.SENSITIVE_STRING }),
-    ...(obj.accessToken && { accessToken: smithyClient.SENSITIVE_STRING }),
-});
-const CustomConnectorProfileCredentialsFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.basic && { basic: BasicAuthCredentialsFilterSensitiveLog(obj.basic) }),
-    ...(obj.oauth2 && { oauth2: OAuth2CredentialsFilterSensitiveLog(obj.oauth2) }),
-    ...(obj.apiKey && { apiKey: ApiKeyCredentialsFilterSensitiveLog(obj.apiKey) }),
-    ...(obj.custom && { custom: CustomAuthCredentialsFilterSensitiveLog(obj.custom) }),
-});
-const DatadogConnectorProfileCredentialsFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.apiKey && { apiKey: smithyClient.SENSITIVE_STRING }),
-});
-const GoogleAnalyticsConnectorProfileCredentialsFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.clientSecret && { clientSecret: smithyClient.SENSITIVE_STRING }),
-    ...(obj.accessToken && { accessToken: smithyClient.SENSITIVE_STRING }),
-});
-const HoneycodeConnectorProfileCredentialsFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.accessToken && { accessToken: smithyClient.SENSITIVE_STRING }),
-});
-const InforNexusConnectorProfileCredentialsFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.accessKeyId && { accessKeyId: smithyClient.SENSITIVE_STRING }),
-});
-const MarketoConnectorProfileCredentialsFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.clientSecret && { clientSecret: smithyClient.SENSITIVE_STRING }),
-    ...(obj.accessToken && { accessToken: smithyClient.SENSITIVE_STRING }),
-});
-const PardotConnectorProfileCredentialsFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.accessToken && { accessToken: smithyClient.SENSITIVE_STRING }),
-    ...(obj.clientCredentialsArn && { clientCredentialsArn: smithyClient.SENSITIVE_STRING }),
-});
-const RedshiftConnectorProfileCredentialsFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.password && { password: smithyClient.SENSITIVE_STRING }),
-});
-const SalesforceConnectorProfileCredentialsFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.accessToken && { accessToken: smithyClient.SENSITIVE_STRING }),
-    ...(obj.clientCredentialsArn && { clientCredentialsArn: smithyClient.SENSITIVE_STRING }),
-    ...(obj.jwtToken && { jwtToken: smithyClient.SENSITIVE_STRING }),
-});
-const OAuthCredentialsFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.clientSecret && { clientSecret: smithyClient.SENSITIVE_STRING }),
-    ...(obj.accessToken && { accessToken: smithyClient.SENSITIVE_STRING }),
-});
-const SAPODataConnectorProfileCredentialsFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.basicAuthCredentials && {
-        basicAuthCredentials: BasicAuthCredentialsFilterSensitiveLog(obj.basicAuthCredentials),
-    }),
-    ...(obj.oAuthCredentials && { oAuthCredentials: OAuthCredentialsFilterSensitiveLog(obj.oAuthCredentials) }),
-});
-const ServiceNowConnectorProfileCredentialsFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.password && { password: smithyClient.SENSITIVE_STRING }),
-    ...(obj.oAuth2Credentials && { oAuth2Credentials: OAuth2CredentialsFilterSensitiveLog(obj.oAuth2Credentials) }),
-});
-const SingularConnectorProfileCredentialsFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.apiKey && { apiKey: smithyClient.SENSITIVE_STRING }),
-});
-const SlackConnectorProfileCredentialsFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.clientSecret && { clientSecret: smithyClient.SENSITIVE_STRING }),
-    ...(obj.accessToken && { accessToken: smithyClient.SENSITIVE_STRING }),
-});
-const SnowflakeConnectorProfileCredentialsFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.password && { password: smithyClient.SENSITIVE_STRING }),
-});
-const TrendmicroConnectorProfileCredentialsFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.apiSecretKey && { apiSecretKey: smithyClient.SENSITIVE_STRING }),
-});
-const VeevaConnectorProfileCredentialsFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.password && { password: smithyClient.SENSITIVE_STRING }),
-});
-const ZendeskConnectorProfileCredentialsFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.clientSecret && { clientSecret: smithyClient.SENSITIVE_STRING }),
-    ...(obj.accessToken && { accessToken: smithyClient.SENSITIVE_STRING }),
-});
-const ConnectorProfileCredentialsFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.Amplitude && { Amplitude: AmplitudeConnectorProfileCredentialsFilterSensitiveLog(obj.Amplitude) }),
-    ...(obj.Datadog && { Datadog: DatadogConnectorProfileCredentialsFilterSensitiveLog(obj.Datadog) }),
-    ...(obj.GoogleAnalytics && {
-        GoogleAnalytics: GoogleAnalyticsConnectorProfileCredentialsFilterSensitiveLog(obj.GoogleAnalytics),
-    }),
-    ...(obj.Honeycode && { Honeycode: HoneycodeConnectorProfileCredentialsFilterSensitiveLog(obj.Honeycode) }),
-    ...(obj.InforNexus && { InforNexus: InforNexusConnectorProfileCredentialsFilterSensitiveLog(obj.InforNexus) }),
-    ...(obj.Marketo && { Marketo: MarketoConnectorProfileCredentialsFilterSensitiveLog(obj.Marketo) }),
-    ...(obj.Redshift && { Redshift: RedshiftConnectorProfileCredentialsFilterSensitiveLog(obj.Redshift) }),
-    ...(obj.Salesforce && { Salesforce: SalesforceConnectorProfileCredentialsFilterSensitiveLog(obj.Salesforce) }),
-    ...(obj.ServiceNow && { ServiceNow: ServiceNowConnectorProfileCredentialsFilterSensitiveLog(obj.ServiceNow) }),
-    ...(obj.Singular && { Singular: SingularConnectorProfileCredentialsFilterSensitiveLog(obj.Singular) }),
-    ...(obj.Slack && { Slack: SlackConnectorProfileCredentialsFilterSensitiveLog(obj.Slack) }),
-    ...(obj.Snowflake && { Snowflake: SnowflakeConnectorProfileCredentialsFilterSensitiveLog(obj.Snowflake) }),
-    ...(obj.Trendmicro && { Trendmicro: TrendmicroConnectorProfileCredentialsFilterSensitiveLog(obj.Trendmicro) }),
-    ...(obj.Veeva && { Veeva: VeevaConnectorProfileCredentialsFilterSensitiveLog(obj.Veeva) }),
-    ...(obj.Zendesk && { Zendesk: ZendeskConnectorProfileCredentialsFilterSensitiveLog(obj.Zendesk) }),
-    ...(obj.SAPOData && { SAPOData: SAPODataConnectorProfileCredentialsFilterSensitiveLog(obj.SAPOData) }),
-    ...(obj.CustomConnector && {
-        CustomConnector: CustomConnectorProfileCredentialsFilterSensitiveLog(obj.CustomConnector),
-    }),
-    ...(obj.Pardot && { Pardot: PardotConnectorProfileCredentialsFilterSensitiveLog(obj.Pardot) }),
-});
-const ConnectorProfileConfigFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.connectorProfileCredentials && {
-        connectorProfileCredentials: ConnectorProfileCredentialsFilterSensitiveLog(obj.connectorProfileCredentials),
-    }),
-});
-const CreateConnectorProfileRequestFilterSensitiveLog = (obj) => ({
-    ...obj,
-});
-const UpdateConnectorProfileRequestFilterSensitiveLog = (obj) => ({
-    ...obj,
-});
-
-const se_CancelFlowExecutionsCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/cancel-flow-executions");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        executionIds: (_) => smithyClient._json(_),
-        flowName: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_CreateConnectorProfileCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/create-connector-profile");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        clientToken: [true, (_) => _ ?? uuid.v4()],
-        connectionMode: [],
-        connectorLabel: [],
-        connectorProfileConfig: (_) => smithyClient._json(_),
-        connectorProfileName: [],
-        connectorType: [],
-        kmsArn: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_CreateFlowCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/create-flow");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        clientToken: [true, (_) => _ ?? uuid.v4()],
-        description: [],
-        destinationFlowConfigList: (_) => smithyClient._json(_),
-        flowName: [],
-        kmsArn: [],
-        metadataCatalogConfig: (_) => smithyClient._json(_),
-        sourceFlowConfig: (_) => smithyClient._json(_),
-        tags: (_) => smithyClient._json(_),
-        tasks: (_) => smithyClient._json(_),
-        triggerConfig: (_) => se_TriggerConfig(_),
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_DeleteConnectorProfileCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/delete-connector-profile");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        connectorProfileName: [],
-        forceDelete: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_DeleteFlowCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/delete-flow");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        flowName: [],
-        forceDelete: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_DescribeConnectorCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/describe-connector");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        connectorLabel: [],
-        connectorType: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_DescribeConnectorEntityCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/describe-connector-entity");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        apiVersion: [],
-        connectorEntityName: [],
-        connectorProfileName: [],
-        connectorType: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_DescribeConnectorProfilesCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/describe-connector-profiles");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        connectorLabel: [],
-        connectorProfileNames: (_) => smithyClient._json(_),
-        connectorType: [],
-        maxResults: [],
-        nextToken: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_DescribeConnectorsCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/describe-connectors");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        connectorTypes: (_) => smithyClient._json(_),
-        maxResults: [],
-        nextToken: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_DescribeFlowCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/describe-flow");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        flowName: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_DescribeFlowExecutionRecordsCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/describe-flow-execution-records");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        flowName: [],
-        maxResults: [],
-        nextToken: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_ListConnectorEntitiesCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/list-connector-entities");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        apiVersion: [],
-        connectorProfileName: [],
-        connectorType: [],
-        entitiesPath: [],
-        maxResults: [],
-        nextToken: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_ListConnectorsCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/list-connectors");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        maxResults: [],
-        nextToken: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_ListFlowsCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/list-flows");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        maxResults: [],
-        nextToken: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_ListTagsForResourceCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/tags/{resourceArn}");
-    b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
-    let body;
-    b.m("GET").h(headers).b(body);
-    return b.build();
-};
-const se_RegisterConnectorCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/register-connector");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        clientToken: [true, (_) => _ ?? uuid.v4()],
-        connectorLabel: [],
-        connectorProvisioningConfig: (_) => smithyClient._json(_),
-        connectorProvisioningType: [],
-        description: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_ResetConnectorMetadataCacheCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/reset-connector-metadata-cache");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        apiVersion: [],
-        connectorEntityName: [],
-        connectorProfileName: [],
-        connectorType: [],
-        entitiesPath: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_StartFlowCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/start-flow");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        clientToken: [true, (_) => _ ?? uuid.v4()],
-        flowName: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_StopFlowCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/stop-flow");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        flowName: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_TagResourceCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/tags/{resourceArn}");
-    b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        tags: (_) => smithyClient._json(_),
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_UnregisterConnectorCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/unregister-connector");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        connectorLabel: [],
-        forceDelete: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_UntagResourceCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/tags/{resourceArn}");
-    b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
-    const query = smithyClient.map({
-        [_tK]: [smithyClient.expectNonNull(input.tagKeys, `tagKeys`) != null, () => input[_tK] || []],
-    });
-    let body;
-    b.m("DELETE").h(headers).q(query).b(body);
-    return b.build();
-};
-const se_UpdateConnectorProfileCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/update-connector-profile");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        clientToken: [true, (_) => _ ?? uuid.v4()],
-        connectionMode: [],
-        connectorProfileConfig: (_) => smithyClient._json(_),
-        connectorProfileName: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_UpdateConnectorRegistrationCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/update-connector-registration");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        clientToken: [true, (_) => _ ?? uuid.v4()],
-        connectorLabel: [],
-        connectorProvisioningConfig: (_) => smithyClient._json(_),
-        description: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_UpdateFlowCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/update-flow");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        clientToken: [true, (_) => _ ?? uuid.v4()],
-        description: [],
-        destinationFlowConfigList: (_) => smithyClient._json(_),
-        flowName: [],
-        metadataCatalogConfig: (_) => smithyClient._json(_),
-        sourceFlowConfig: (_) => smithyClient._json(_),
-        tasks: (_) => smithyClient._json(_),
-        triggerConfig: (_) => se_TriggerConfig(_),
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const de_CancelFlowExecutionsCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        invalidExecutions: smithyClient._json,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_CreateConnectorProfileCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        connectorProfileArn: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_CreateFlowCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        flowArn: smithyClient.expectString,
-        flowStatus: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_DeleteConnectorProfileCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    await smithyClient.collectBody(output.body, context);
-    return contents;
-};
-const de_DeleteFlowCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    await smithyClient.collectBody(output.body, context);
-    return contents;
-};
-const de_DescribeConnectorCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        connectorConfiguration: (_) => de_ConnectorConfiguration(_),
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_DescribeConnectorEntityCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        connectorEntityFields: (_) => de_ConnectorEntityFieldList(_),
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_DescribeConnectorProfilesCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        connectorProfileDetails: (_) => de_ConnectorProfileDetailList(_),
-        nextToken: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_DescribeConnectorsCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        connectorConfigurations: (_) => de_ConnectorConfigurationsMap(_),
-        connectors: (_) => de_ConnectorList(_),
-        nextToken: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_DescribeFlowCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        createdAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        createdBy: smithyClient.expectString,
-        description: smithyClient.expectString,
-        destinationFlowConfigList: smithyClient._json,
-        flowArn: smithyClient.expectString,
-        flowName: smithyClient.expectString,
-        flowStatus: smithyClient.expectString,
-        flowStatusMessage: smithyClient.expectString,
-        kmsArn: smithyClient.expectString,
-        lastRunExecutionDetails: (_) => de_ExecutionDetails(_),
-        lastRunMetadataCatalogDetails: smithyClient._json,
-        lastUpdatedAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        lastUpdatedBy: smithyClient.expectString,
-        metadataCatalogConfig: smithyClient._json,
-        schemaVersion: smithyClient.expectLong,
-        sourceFlowConfig: smithyClient._json,
-        tags: smithyClient._json,
-        tasks: smithyClient._json,
-        triggerConfig: (_) => de_TriggerConfig(_),
-    });
-    Object.assign(contents, doc);
-    return contents;
 };
-const de_DescribeFlowExecutionRecordsCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        flowExecutions: (_) => de_FlowExecutionList(_),
-        nextToken: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_ListConnectorEntitiesCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        connectorEntityMap: smithyClient._json,
-        nextToken: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_ListConnectorsCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        connectors: (_) => de_ConnectorList(_),
-        nextToken: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_ListFlowsCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        flows: (_) => de_FlowList(_),
-        nextToken: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_ListTagsForResourceCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        tags: smithyClient._json,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_RegisterConnectorCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        connectorArn: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_ResetConnectorMetadataCacheCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    await smithyClient.collectBody(output.body, context);
-    return contents;
-};
-const de_StartFlowCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        executionId: smithyClient.expectString,
-        flowArn: smithyClient.expectString,
-        flowStatus: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_StopFlowCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        flowArn: smithyClient.expectString,
-        flowStatus: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_TagResourceCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    await smithyClient.collectBody(output.body, context);
-    return contents;
-};
-const de_UnregisterConnectorCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    await smithyClient.collectBody(output.body, context);
-    return contents;
-};
-const de_UntagResourceCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    await smithyClient.collectBody(output.body, context);
-    return contents;
-};
-const de_UpdateConnectorProfileCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        connectorProfileArn: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_UpdateConnectorRegistrationCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        connectorArn: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_UpdateFlowCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        flowStatus: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_CommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await core$1.parseJsonErrorBody(output.body, context),
-    };
-    const errorCode = core$1.loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "AccessDeniedException":
-        case "com.amazonaws.appflow#AccessDeniedException":
-            throw await de_AccessDeniedExceptionRes(parsedOutput);
-        case "InternalServerException":
-        case "com.amazonaws.appflow#InternalServerException":
-            throw await de_InternalServerExceptionRes(parsedOutput);
-        case "ResourceNotFoundException":
-        case "com.amazonaws.appflow#ResourceNotFoundException":
-            throw await de_ResourceNotFoundExceptionRes(parsedOutput);
-        case "ThrottlingException":
-        case "com.amazonaws.appflow#ThrottlingException":
-            throw await de_ThrottlingExceptionRes(parsedOutput);
-        case "ValidationException":
-        case "com.amazonaws.appflow#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput);
-        case "ConflictException":
-        case "com.amazonaws.appflow#ConflictException":
-            throw await de_ConflictExceptionRes(parsedOutput);
-        case "ConnectorAuthenticationException":
-        case "com.amazonaws.appflow#ConnectorAuthenticationException":
-            throw await de_ConnectorAuthenticationExceptionRes(parsedOutput);
-        case "ServiceQuotaExceededException":
-        case "com.amazonaws.appflow#ServiceQuotaExceededException":
-            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput);
-        case "ConnectorServerException":
-        case "com.amazonaws.appflow#ConnectorServerException":
-            throw await de_ConnectorServerExceptionRes(parsedOutput);
-        case "UnsupportedOperationException":
-        case "com.amazonaws.appflow#UnsupportedOperationException":
-            throw await de_UnsupportedOperationExceptionRes(parsedOutput);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-const throwDefaultError = smithyClient.withBaseException(AppflowServiceException);
-const de_AccessDeniedExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        message: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new AccessDeniedException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_ConflictExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        message: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new ConflictException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_ConnectorAuthenticationExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        message: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new ConnectorAuthenticationException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_ConnectorServerExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        message: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new ConnectorServerException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_InternalServerExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        message: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new InternalServerException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_ResourceNotFoundExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        message: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new ResourceNotFoundException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_ServiceQuotaExceededExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        message: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new ServiceQuotaExceededException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_ThrottlingExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        message: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new ThrottlingException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_UnsupportedOperationExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        message: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new UnsupportedOperationException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_ValidationExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        message: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new ValidationException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const se_ScheduledTriggerProperties = (input, context) => {
-    return smithyClient.take(input, {
-        dataPullMode: [],
-        firstExecutionFrom: (_) => _.getTime() / 1_000,
-        flowErrorDeactivationThreshold: [],
-        scheduleEndTime: (_) => _.getTime() / 1_000,
-        scheduleExpression: [],
-        scheduleOffset: [],
-        scheduleStartTime: (_) => _.getTime() / 1_000,
-        timezone: [],
-    });
-};
-const se_TriggerConfig = (input, context) => {
-    return smithyClient.take(input, {
-        triggerProperties: (_) => se_TriggerProperties(_),
-        triggerType: [],
-    });
-};
-const se_TriggerProperties = (input, context) => {
-    return smithyClient.take(input, {
-        Scheduled: (_) => se_ScheduledTriggerProperties(_),
-    });
-};
-const de_ConnectorConfiguration = (output, context) => {
-    return smithyClient.take(output, {
-        authenticationConfig: smithyClient._json,
-        canUseAsDestination: smithyClient.expectBoolean,
-        canUseAsSource: smithyClient.expectBoolean,
-        connectorArn: smithyClient.expectString,
-        connectorDescription: smithyClient.expectString,
-        connectorLabel: smithyClient.expectString,
-        connectorMetadata: smithyClient._json,
-        connectorModes: smithyClient._json,
-        connectorName: smithyClient.expectString,
-        connectorOwner: smithyClient.expectString,
-        connectorProvisioningConfig: smithyClient._json,
-        connectorProvisioningType: smithyClient.expectString,
-        connectorRuntimeSettings: smithyClient._json,
-        connectorType: smithyClient.expectString,
-        connectorVersion: smithyClient.expectString,
-        isPrivateLinkEnabled: smithyClient.expectBoolean,
-        isPrivateLinkEndpointUrlRequired: smithyClient.expectBoolean,
-        logoURL: smithyClient.expectString,
-        registeredAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        registeredBy: smithyClient.expectString,
-        supportedApiVersions: smithyClient._json,
-        supportedDataTransferApis: smithyClient._json,
-        supportedDataTransferTypes: smithyClient._json,
-        supportedDestinationConnectors: smithyClient._json,
-        supportedOperators: smithyClient._json,
-        supportedSchedulingFrequencies: smithyClient._json,
-        supportedTriggerTypes: smithyClient._json,
-        supportedWriteOperations: smithyClient._json,
-    });
-};
-const de_ConnectorConfigurationsMap = (output, context) => {
-    return Object.entries(output).reduce((acc, [key, value]) => {
-        if (value === null) {
-            return acc;
-        }
-        acc[key] = de_ConnectorConfiguration(value);
-        return acc;
-    }, {});
-};
-const de_ConnectorDetail = (output, context) => {
-    return smithyClient.take(output, {
-        applicationType: smithyClient.expectString,
-        connectorDescription: smithyClient.expectString,
-        connectorLabel: smithyClient.expectString,
-        connectorModes: smithyClient._json,
-        connectorName: smithyClient.expectString,
-        connectorOwner: smithyClient.expectString,
-        connectorProvisioningType: smithyClient.expectString,
-        connectorType: smithyClient.expectString,
-        connectorVersion: smithyClient.expectString,
-        registeredAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        registeredBy: smithyClient.expectString,
-        supportedDataTransferTypes: smithyClient._json,
-    });
-};
-const de_ConnectorEntityField = (output, context) => {
-    return smithyClient.take(output, {
-        customProperties: smithyClient._json,
-        defaultValue: smithyClient.expectString,
-        description: smithyClient.expectString,
-        destinationProperties: smithyClient._json,
-        identifier: smithyClient.expectString,
-        isDeprecated: smithyClient.expectBoolean,
-        isPrimaryKey: smithyClient.expectBoolean,
-        label: smithyClient.expectString,
-        parentIdentifier: smithyClient.expectString,
-        sourceProperties: smithyClient._json,
-        supportedFieldTypeDetails: (_) => de_SupportedFieldTypeDetails(_),
-    });
-};
-const de_ConnectorEntityFieldList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_ConnectorEntityField(entry);
-    });
-    return retVal;
-};
-const de_ConnectorList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_ConnectorDetail(entry);
-    });
-    return retVal;
-};
-const de_ConnectorProfile = (output, context) => {
-    return smithyClient.take(output, {
-        connectionMode: smithyClient.expectString,
-        connectorLabel: smithyClient.expectString,
-        connectorProfileArn: smithyClient.expectString,
-        connectorProfileName: smithyClient.expectString,
-        connectorProfileProperties: smithyClient._json,
-        connectorType: smithyClient.expectString,
-        createdAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        credentialsArn: smithyClient.expectString,
-        lastUpdatedAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        privateConnectionProvisioningState: smithyClient._json,
-    });
-};
-const de_ConnectorProfileDetailList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_ConnectorProfile(entry);
-    });
-    return retVal;
-};
-const de_ExecutionDetails = (output, context) => {
-    return smithyClient.take(output, {
-        mostRecentExecutionMessage: smithyClient.expectString,
-        mostRecentExecutionStatus: smithyClient.expectString,
-        mostRecentExecutionTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-    });
-};
-const de_ExecutionRecord = (output, context) => {
-    return smithyClient.take(output, {
-        dataPullEndTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        dataPullStartTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        executionId: smithyClient.expectString,
-        executionResult: smithyClient._json,
-        executionStatus: smithyClient.expectString,
-        lastUpdatedAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        metadataCatalogDetails: smithyClient._json,
-        startedAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-    });
-};
-const de_FieldTypeDetails = (output, context) => {
-    return smithyClient.take(output, {
-        fieldLengthRange: (_) => de_Range(_),
-        fieldType: smithyClient.expectString,
-        fieldValueRange: (_) => de_Range(_),
-        filterOperators: smithyClient._json,
-        supportedDateFormat: smithyClient.expectString,
-        supportedValues: smithyClient._json,
-        valueRegexPattern: smithyClient.expectString,
-    });
-};
-const de_FlowDefinition = (output, context) => {
-    return smithyClient.take(output, {
-        createdAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        createdBy: smithyClient.expectString,
-        description: smithyClient.expectString,
-        destinationConnectorLabel: smithyClient.expectString,
-        destinationConnectorType: smithyClient.expectString,
-        flowArn: smithyClient.expectString,
-        flowName: smithyClient.expectString,
-        flowStatus: smithyClient.expectString,
-        lastRunExecutionDetails: (_) => de_ExecutionDetails(_),
-        lastUpdatedAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        lastUpdatedBy: smithyClient.expectString,
-        sourceConnectorLabel: smithyClient.expectString,
-        sourceConnectorType: smithyClient.expectString,
-        tags: smithyClient._json,
-        triggerType: smithyClient.expectString,
-    });
-};
-const de_FlowExecutionList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_ExecutionRecord(entry);
-    });
-    return retVal;
-};
-const de_FlowList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_FlowDefinition(entry);
-    });
-    return retVal;
-};
-const de_Range = (output, context) => {
-    return smithyClient.take(output, {
-        maximum: smithyClient.limitedParseDouble,
-        minimum: smithyClient.limitedParseDouble,
-    });
-};
-const de_ScheduledTriggerProperties = (output, context) => {
-    return smithyClient.take(output, {
-        dataPullMode: smithyClient.expectString,
-        firstExecutionFrom: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        flowErrorDeactivationThreshold: smithyClient.expectInt32,
-        scheduleEndTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        scheduleExpression: smithyClient.expectString,
-        scheduleOffset: smithyClient.expectLong,
-        scheduleStartTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        timezone: smithyClient.expectString,
-    });
-};
-const de_SupportedFieldTypeDetails = (output, context) => {
-    return smithyClient.take(output, {
-        v1: (_) => de_FieldTypeDetails(_),
-    });
-};
-const de_TriggerConfig = (output, context) => {
-    return smithyClient.take(output, {
-        triggerProperties: (_) => de_TriggerProperties(_),
-        triggerType: smithyClient.expectString,
-    });
-};
-const de_TriggerProperties = (output, context) => {
-    return smithyClient.take(output, {
-        Scheduled: (_) => de_ScheduledTriggerProperties(_),
-    });
-};
-const deserializeMetadata = (output) => ({
-    httpStatusCode: output.statusCode,
-    requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],
-    extendedRequestId: output.headers["x-amz-id-2"],
-    cfId: output.headers["x-amz-cf-id"],
-});
+
+const _A = "Amplitude";
+const _AC = "AggregationConfig";
+const _ACPC = "AmplitudeConnectorProfileCredentials";
+const _ACPP = "AmplitudeConnectorProfileProperties";
+const _ACu = "AuthenticationConfig";
+const _ADE = "AccessDeniedException";
+const _AK = "ApiKey";
+const _AKC = "ApiKeyCredentials";
+const _AKI = "AccessKeyId";
+const _AM = "AmplitudeMetadata";
+const _AP = "AuthParameter";
+const _APL = "AuthParameterList";
+const _ASK = "ApiSecretKey";
+const _ASP = "AmplitudeSourceProperties";
+const _AT = "AccessToken";
+const _BAC = "BasicAuthCredentials";
+const _CAC = "CustomAuthConfig";
+const _CACL = "CustomAuthConfigList";
+const _CACu = "CustomAuthCredentials";
+const _CAE = "ConnectorAuthenticationException";
+const _CC = "ConnectorConfiguration";
+const _CCA = "ClientCredentialsArn";
+const _CCDP = "CustomConnectorDestinationProperties";
+const _CCM = "ConnectorConfigurationsMap";
+const _CCP = "CreateConnectorProfile";
+const _CCPC = "CustomConnectorProfileCredentials";
+const _CCPP = "CustomConnectorProfileProperties";
+const _CCPR = "CreateConnectorProfileRequest";
+const _CCPRr = "CreateConnectorProfileResponse";
+const _CCSP = "CustomConnectorSourceProperties";
+const _CCu = "CustomConnector";
+const _CD = "ConnectorDetail";
+const _CE = "ConflictException";
+const _CEF = "ConnectorEntityField";
+const _CEFL = "ConnectorEntityFieldList";
+const _CEL = "ConnectorEntityList";
+const _CEM = "ConnectorEntityMap";
+const _CEo = "ConnectorEntity";
+const _CF = "CreateFlow";
+const _CFE = "CancelFlowExecutions";
+const _CFER = "CancelFlowExecutionsRequest";
+const _CFERa = "CancelFlowExecutionsResponse";
+const _CFR = "CreateFlowRequest";
+const _CFRr = "CreateFlowResponse";
+const _CL = "ConnectorList";
+const _CM = "ConnectorMetadata";
+const _CMK = "CredentialsMapKey";
+const _CMV = "CredentialsMapValue";
+const _CMr = "CredentialsMap";
+const _CO = "ConnectorOperator";
+const _COAR = "ConnectorOAuthRequest";
+const _CP = "CustomerProfiles";
+const _CPC = "ConnectorProfileConfig";
+const _CPCo = "ConnectorProfileCredentials";
+const _CPCon = "ConnectorProvisioningConfig";
+const _CPDL = "ConnectorProfileDetailList";
+const _CPDP = "CustomerProfilesDestinationProperties";
+const _CPM = "CustomerProfilesMetadata";
+const _CPP = "ConnectorProfileProperties";
+const _CPo = "ConnectorProfile";
+const _CRS = "ConnectorRuntimeSetting";
+const _CRSL = "ConnectorRuntimeSettingList";
+const _CS = "ClientSecret";
+const _CSE = "ConnectorServerException";
+const _D = "Datadog";
+const _DC = "DescribeConnector";
+const _DCE = "DescribeConnectorEntity";
+const _DCER = "DescribeConnectorEntityRequest";
+const _DCERe = "DescribeConnectorEntityResponse";
+const _DCP = "DestinationConnectorProperties";
+const _DCPC = "DatadogConnectorProfileCredentials";
+const _DCPCy = "DynatraceConnectorProfileCredentials";
+const _DCPP = "DatadogConnectorProfileProperties";
+const _DCPPy = "DynatraceConnectorProfileProperties";
+const _DCPR = "DeleteConnectorProfileRequest";
+const _DCPRe = "DeleteConnectorProfileResponse";
+const _DCPRes = "DescribeConnectorProfilesRequest";
+const _DCPResc = "DescribeConnectorProfilesResponse";
+const _DCPe = "DeleteConnectorProfile";
+const _DCPes = "DescribeConnectorProfiles";
+const _DCR = "DescribeConnectorRequest";
+const _DCRe = "DescribeConnectorResponse";
+const _DCRes = "DescribeConnectorsRequest";
+const _DCResc = "DescribeConnectorsResponse";
+const _DCe = "DescribeConnectors";
+const _DF = "DeleteFlow";
+const _DFC = "DestinationFlowConfig";
+const _DFCL = "DestinationFlowConfigList";
+const _DFER = "DescribeFlowExecutionRecords";
+const _DFERR = "DescribeFlowExecutionRecordsRequest";
+const _DFERRe = "DescribeFlowExecutionRecordsResponse";
+const _DFP = "DestinationFieldProperties";
+const _DFR = "DeleteFlowRequest";
+const _DFRe = "DeleteFlowResponse";
+const _DFRes = "DescribeFlowRequest";
+const _DFResc = "DescribeFlowResponse";
+const _DFe = "DescribeFlow";
+const _DM = "DatadogMetadata";
+const _DMy = "DynatraceMetadata";
+const _DSP = "DatadogSourceProperties";
+const _DSPy = "DynatraceSourceProperties";
+const _DTA = "DataTransferApi";
+const _Dy = "Dynatrace";
+const _EB = "EventBridge";
+const _EBDP = "EventBridgeDestinationProperties";
+const _EBM = "EventBridgeMetadata";
+const _ED = "ExecutionDetails";
+const _EHC = "ErrorHandlingConfig";
+const _EI = "ErrorInfo";
+const _ER = "ExecutionRecord";
+const _ERx = "ExecutionResult";
+const _FD = "FlowDefinition";
+const _FEL = "FlowExecutionList";
+const _FL = "FlowList";
+const _FTD = "FieldTypeDetails";
+const _GA = "GoogleAnalytics";
+const _GACPC = "GoogleAnalyticsConnectorProfileCredentials";
+const _GACPP = "GoogleAnalyticsConnectorProfileProperties";
+const _GAM = "GoogleAnalyticsMetadata";
+const _GASP = "GoogleAnalyticsSourceProperties";
+const _GDCC = "GlueDataCatalogConfig";
+const _H = "Honeycode";
+const _HCPC = "HoneycodeConnectorProfileCredentials";
+const _HCPP = "HoneycodeConnectorProfileProperties";
+const _HDP = "HoneycodeDestinationProperties";
+const _HM = "HoneycodeMetadata";
+const _IN = "InforNexus";
+const _INCPC = "InforNexusConnectorProfileCredentials";
+const _INCPP = "InforNexusConnectorProfileProperties";
+const _INM = "InforNexusMetadata";
+const _INSP = "InforNexusSourceProperties";
+const _IPC = "IncrementalPullConfig";
+const _ISE = "InternalServerException";
+const _JT = "JwtToken";
+const _LC = "ListConnectors";
+const _LCE = "ListConnectorEntities";
+const _LCER = "ListConnectorEntitiesRequest";
+const _LCERi = "ListConnectorEntitiesResponse";
+const _LCPC = "LambdaConnectorProvisioningConfig";
+const _LCR = "ListConnectorsRequest";
+const _LCRi = "ListConnectorsResponse";
+const _LF = "ListFlows";
+const _LFR = "ListFlowsRequest";
+const _LFRi = "ListFlowsResponse";
+const _LM = "LookoutMetrics";
+const _LMDP = "LookoutMetricsDestinationProperties";
+const _LTFR = "ListTagsForResource";
+const _LTFRR = "ListTagsForResourceRequest";
+const _LTFRRi = "ListTagsForResourceResponse";
+const _M = "Marketo";
+const _MCC = "MetadataCatalogConfig";
+const _MCD = "MetadataCatalogDetail";
+const _MCDe = "MetadataCatalogDetails";
+const _MCPC = "MarketoConnectorProfileCredentials";
+const _MCPP = "MarketoConnectorProfileProperties";
+const _MDP = "MarketoDestinationProperties";
+const _MM = "MarketoMetadata";
+const _MSP = "MarketoSourceProperties";
+const _N = "Name";
+const _OAC = "OAuth2Credentials";
+const _OACP = "OAuth2CustomParameter";
+const _OACPL = "OAuth2CustomPropertiesList";
+const _OACu = "OAuthCredentials";
+const _OAD = "OAuth2Defaults";
+const _OAP = "OAuth2Properties";
+const _OAPu = "OAuthProperties";
+const _P = "Password";
+const _PC = "PrefixConfig";
+const _PCPC = "PardotConnectorProfileCredentials";
+const _PCPP = "PardotConnectorProfileProperties";
+const _PCPS = "PrivateConnectionProvisioningState";
+const _PM = "PardotMetadata";
+const _PSP = "PardotSourceProperties";
+const _Pa = "Pardot";
+const _R = "Redshift";
+const _RC = "RegisterConnector";
+const _RCMC = "ResetConnectorMetadataCache";
+const _RCMCR = "ResetConnectorMetadataCacheRequest";
+const _RCMCRe = "ResetConnectorMetadataCacheResponse";
+const _RCPC = "RedshiftConnectorProfileCredentials";
+const _RCPP = "RedshiftConnectorProfileProperties";
+const _RCR = "RegisterConnectorRequest";
+const _RCRe = "RegisterConnectorResponse";
+const _RDP = "RedshiftDestinationProperties";
+const _RM = "RedshiftMetadata";
+const _RNFE = "ResourceNotFoundException";
+const _RO = "RegistrationOutput";
+const _Ra = "Range";
+const _S = "S3";
+const _SAPOD = "SAPOData";
+const _SAPODCPC = "SAPODataConnectorProfileCredentials";
+const _SAPODCPP = "SAPODataConnectorProfileProperties";
+const _SAPODDP = "SAPODataDestinationProperties";
+const _SAPODM = "SAPODataMetadata";
+const _SAPODPC = "SAPODataPaginationConfig";
+const _SAPODPCa = "SAPODataParallelismConfig";
+const _SAPODSP = "SAPODataSourceProperties";
+const _SCP = "SourceConnectorProperties";
+const _SCPC = "SalesforceConnectorProfileCredentials";
+const _SCPCi = "SingularConnectorProfileCredentials";
+const _SCPCl = "SlackConnectorProfileCredentials";
+const _SCPCn = "SnowflakeConnectorProfileCredentials";
+const _SCPP = "SalesforceConnectorProfileProperties";
+const _SCPPi = "SingularConnectorProfileProperties";
+const _SCPPl = "SlackConnectorProfileProperties";
+const _SCPPn = "SnowflakeConnectorProfileProperties";
+const _SDP = "S3DestinationProperties";
+const _SDPa = "SalesforceDestinationProperties";
+const _SDPn = "SnowflakeDestinationProperties";
+const _SDTA = "SupportedDataTransferApis";
+const _SF = "StartFlow";
+const _SFC = "SourceFlowConfig";
+const _SFP = "SourceFieldProperties";
+const _SFR = "StartFlowRequest";
+const _SFRt = "StartFlowResponse";
+const _SFRto = "StopFlowRequest";
+const _SFRtop = "StopFlowResponse";
+const _SFTD = "SupportedFieldTypeDetails";
+const _SFt = "StopFlow";
+const _SIFC = "S3InputFormatConfig";
+const _SK = "SecretKey";
+const _SM = "S3Metadata";
+const _SMa = "SalesforceMetadata";
+const _SMi = "SingularMetadata";
+const _SMl = "SlackMetadata";
+const _SMn = "SnowflakeMetadata";
+const _SN = "ServiceNow";
+const _SNCPC = "ServiceNowConnectorProfileCredentials";
+const _SNCPP = "ServiceNowConnectorProfileProperties";
+const _SNM = "ServiceNowMetadata";
+const _SNSP = "ServiceNowSourceProperties";
+const _SOFC = "S3OutputFormatConfig";
+const _SQEE = "ServiceQuotaExceededException";
+const _SRHC = "SuccessResponseHandlingConfig";
+const _SSP = "S3SourceProperties";
+const _SSPa = "SalesforceSourceProperties";
+const _SSPi = "SingularSourceProperties";
+const _SSPl = "SlackSourceProperties";
+const _STP = "ScheduledTriggerProperties";
+const _Sa = "Salesforce";
+const _Sc = "Scheduled";
+const _Si = "Singular";
+const _Sl = "Slack";
+const _Sn = "Snowflake";
+const _T = "Trendmicro";
+const _TC = "TriggerConfig";
+const _TCPC = "TrendmicroConnectorProfileCredentials";
+const _TCPP = "TrendmicroConnectorProfileProperties";
+const _TE = "ThrottlingException";
+const _TM = "TrendmicroMetadata";
+const _TP = "TriggerProperties";
+const _TR = "TagResource";
+const _TRR = "TagResourceRequest";
+const _TRRa = "TagResourceResponse";
+const _TSP = "TrendmicroSourceProperties";
+const _Ta = "Task";
+const _Tas = "Tasks";
+const _Ty = "Type";
+const _U = "Upsolver";
+const _UC = "UnregisterConnector";
+const _UCP = "UpdateConnectorProfile";
+const _UCPR = "UpdateConnectorProfileRequest";
+const _UCPRp = "UpdateConnectorProfileResponse";
+const _UCR = "UnregisterConnectorRequest";
+const _UCRR = "UpdateConnectorRegistrationRequest";
+const _UCRRp = "UpdateConnectorRegistrationResponse";
+const _UCRn = "UnregisterConnectorResponse";
+const _UCRp = "UpdateConnectorRegistration";
+const _UDP = "UpsolverDestinationProperties";
+const _UF = "UpdateFlow";
+const _UFR = "UpdateFlowRequest";
+const _UFRp = "UpdateFlowResponse";
+const _UM = "UpsolverMetadata";
+const _UOE = "UnsupportedOperationException";
+const _UR = "UntagResource";
+const _URR = "UntagResourceRequest";
+const _URRn = "UntagResourceResponse";
+const _USOFC = "UpsolverS3OutputFormatConfig";
+const _V = "Veeva";
+const _VCPC = "VeevaConnectorProfileCredentials";
+const _VCPP = "VeevaConnectorProfileProperties";
+const _VE = "ValidationException";
+const _VM = "VeevaMetadata";
+const _VSP = "VeevaSourceProperties";
+const _Z = "Zendesk";
+const _ZCPC = "ZendeskConnectorProfileCredentials";
+const _ZCPP = "ZendeskConnectorProfileProperties";
+const _ZDP = "ZendeskDestinationProperties";
+const _ZM = "ZendeskMetadata";
+const _ZSP = "ZendeskSourceProperties";
+const _aC = "authenticationConfig";
+const _aCU = "authCodeUrls";
+const _aCUu = "authCodeUrl";
+const _aCg = "aggregationConfig";
+const _aCu = "authCode";
+const _aHU = "applicationHostUrl";
+const _aK = "apiKey";
+const _aKI = "accessKeyId";
+const _aKp = "applicationKey";
+const _aN = "accountName";
+const _aP = "authParameters";
+const _aSK = "apiSecretKey";
+const _aSP = "applicationServicePath";
+const _aT = "aggregationType";
+const _aTc = "accessToken";
+const _aTp = "applicationType";
+const _aTpi = "apiToken";
+const _aTu = "authenticationType";
+const _aV = "apiVersion";
+const _b = "basic";
+const _bAC = "basicAuthCredentials";
+const _bN = "bucketName";
+const _bP = "bucketPrefix";
+const _bPy = "bytesProcessed";
+const _bUI = "businessUnitId";
+const _bW = "bytesWritten";
+const _c = "client";
+const _cA = "connectorArn";
+const _cAC = "customAuthConfigs";
+const _cAT = "customAuthenticationType";
+const _cAr = "credentialsArn";
+const _cAre = "createdAt";
+const _cB = "createdBy";
+const _cC = "connectorConfiguration";
+const _cCA = "clientCredentialsArn";
+const _cCo = "connectorConfigurations";
+const _cD = "connectorDescription";
+const _cEF = "connectorEntityFields";
+const _cEM = "connectorEntityMap";
+const _cEN = "connectorEntityName";
+const _cI = "clientId";
+const _cIl = "clusterIdentifier";
+const _cL = "connectorLabel";
+const _cM = "connectorMetadata";
+const _cMo = "connectorModes";
+const _cMon = "connectionMode";
+const _cMr = "credentialsMap";
+const _cN = "connectorName";
+const _cNl = "clientNumber";
+const _cO = "connectorOwner";
+const _cOo = "connectorOperator";
+const _cP = "customProperties";
+const _cPA = "connectorProfileArn";
+const _cPC = "connectorProvisioningConfig";
+const _cPCo = "connectorProfileCredentials";
+const _cPCon = "connectorProfileConfig";
+const _cPD = "connectorProfileDetails";
+const _cPN = "connectorProfileName";
+const _cPNo = "connectorProfileNames";
+const _cPP = "connectorProfileProperties";
+const _cPT = "connectorProvisioningType";
+const _cRS = "connectorRuntimeSettings";
+const _cS = "clientSecret";
+const _cSV = "connectorSuppliedValues";
+const _cSVO = "connectorSuppliedValueOptions";
+const _cT = "connectorType";
+const _cTa = "catalogType";
+const _cTl = "clientToken";
+const _cTo = "connectorTypes";
+const _cUAD = "canUseAsDestination";
+const _cUAS = "canUseAsSource";
+const _cV = "connectorVersion";
+const _co = "connectors";
+const _cu = "custom";
+const _d = "description";
+const _dARA = "dataApiRoleArn";
+const _dCL = "destinationConnectorLabel";
+const _dCP = "destinationConnectorProperties";
+const _dCT = "destinationConnectorType";
+const _dF = "destinationField";
+const _dFCL = "destinationFlowConfigList";
+const _dN = "domainName";
+const _dNa = "databaseName";
+const _dP = "destinationProperties";
+const _dPET = "dataPullEndTime";
+const _dPM = "dataPullMode";
+const _dPST = "dataPullStartTime";
+const _dSSO = "disableSSO";
+const _dT = "dataType";
+const _dTA = "dataTransferApi";
+const _dTAa = "dataTransferApis";
+const _dTFN = "datetimeTypeFieldName";
+const _dTo = "documentType";
+const _dU = "databaseUrl";
+const _dV = "defaultValue";
+const _da = "datakey";
+const _e = "error";
+const _eDFU = "enableDynamicFieldUpdate";
+const _eHC = "errorHandlingConfig";
+const _eI = "executionIds";
+const _eIr = "errorInfo";
+const _eIx = "executionId";
+const _eM = "executionMessage";
+const _eN = "entityName";
+const _eP = "entitiesPath";
+const _eR = "executionResult";
+const _eS = "executionStatus";
+const _f = "flows";
+const _fA = "flowArn";
+const _fC = "failureCause";
+const _fD = "forceDelete";
+const _fE = "flowExecutions";
+const _fEDT = "flowErrorDeactivationThreshold";
+const _fEF = "firstExecutionFrom";
+const _fLR = "fieldLengthRange";
+const _fM = "failureMessage";
+const _fN = "flowName";
+const _fO = "filterOperators";
+const _fOFDE = "failOnFirstDestinationError";
+const _fS = "flowStatus";
+const _fSM = "flowStatusMessage";
+const _fT = "fieldType";
+const _fTi = "fileType";
+const _fVR = "fieldValueRange";
+const _gDC = "glueDataCatalog";
+const _h = "http";
+const _hE = "httpError";
+const _hNE = "hasNestedEntities";
+const _hQ = "httpQuery";
+const _i = "identifier";
+const _iAKAS = "isApiKeyAuthSupported";
+const _iAV = "includeAllVersions";
+const _iBAS = "isBasicAuthSupported";
+const _iBN = "intermediateBucketName";
+const _iC = "isCreatable";
+const _iCAS = "isCustomAuthSupported";
+const _iD = "isDeprecated";
+const _iDOC = "isDefaultedOnCreate";
+const _iDR = "includeDeletedRecords";
+const _iE = "invalidExecutions";
+const _iFN = "idFieldNames";
+const _iN = "isNullable";
+const _iOAS = "isOAuth2Supported";
+const _iPC = "incrementalPullConfig";
+const _iPK = "isPrimaryKey";
+const _iPLE = "isPrivateLinkEnabled";
+const _iPLEUR = "isPrivateLinkEndpointUrlRequired";
+const _iQ = "isQueryable";
+const _iR = "isRequired";
+const _iRS = "isRedshiftServerless";
+const _iRn = "includeRenditions";
+const _iRs = "isRetrievable";
+const _iSE = "isSandboxEnvironment";
+const _iSF = "isSensitiveField";
+const _iSFn = "includeSourceFiles";
+const _iTFFIQ = "isTimestampFieldForIncrementalQueries";
+const _iU = "instanceUrl";
+const _iUs = "isUpsertable";
+const _iUsp = "isUpdatable";
+const _jT = "jwtToken";
+const _k = "key";
+const _kA = "kmsArn";
+const _l = "label";
+const _lA = "lambdaArn";
+const _lL = "logonLanguage";
+const _lRED = "lastRunExecutionDetails";
+const _lRMCD = "lastRunMetadataCatalogDetails";
+const _lUA = "lastUpdatedAt";
+const _lUB = "lastUpdatedBy";
+const _lURL = "logoURL";
+const _la = "lambda";
+const _m = "message";
+const _mCC = "metadataCatalogConfig";
+const _mCD = "metadataCatalogDetails";
+const _mP = "maxParallelism";
+const _mPS = "maxPageSize";
+const _mR = "maxResults";
+const _mREM = "mostRecentExecutionMessage";
+const _mRES = "mostRecentExecutionStatus";
+const _mRET = "mostRecentExecutionTime";
+const _ma = "maximum";
+const _mi = "minimum";
+const _n = "name";
+const _nPP = "numParallelProcesses";
+const _nT = "nextToken";
+const _o = "object";
+const _oAC = "oAuthCredentials";
+const _oACu = "oAuth2Credentials";
+const _oAD = "oAuth2Defaults";
+const _oAGT = "oAuth2GrantType";
+const _oAP = "oAuth2Properties";
+const _oAPu = "oAuthProperties";
+const _oAR = "oAuthRequest";
+const _oAS = "oAuthScopes";
+const _oCP = "oauth2CustomProperties";
+const _oGTS = "oauth2GrantTypesSupported";
+const _oP = "objectPath";
+const _oS = "oauthScopes";
+const _oTN = "objectTypeName";
+const _oa = "oauth2";
+const _p = "password";
+const _pC = "prefixConfig";
+const _pCPS = "privateConnectionProvisioningState";
+const _pCa = "parallelismConfig";
+const _pCag = "paginationConfig";
+const _pF = "prefixFormat";
+const _pFC = "putFailuresCount";
+const _pI = "parentIdentifier";
+const _pLSN = "privateLinkServiceName";
+const _pN = "portNumber";
+const _pP = "profileProperties";
+const _pPH = "pathPrefixHierarchy";
+const _pRO = "partitionRegistrationOutput";
+const _pSDT = "preserveSourceDataTyping";
+const _pT = "prefixType";
+const _r = "result";
+const _rA = "registeredAt";
+const _rAe = "resourceArn";
+const _rAo = "roleArn";
+const _rB = "registeredBy";
+const _rP = "recordsProcessed";
+const _rT = "refreshToken";
+const _rU = "redirectUri";
+const _re = "region";
+const _s = "scope";
+const _sA = "startedAt";
+const _sAK = "secretAccessKey";
+const _sAV = "supportedApiVersions";
+const _sCL = "sourceConnectorLabel";
+const _sCP = "sourceConnectorProperties";
+const _sCT = "sourceConnectorType";
+const _sDC = "supportedDestinationConnectors";
+const _sDF = "supportedDateFormat";
+const _sDTA = "supportedDataTransferApis";
+const _sDTT = "supportedDataTransferTypes";
+const _sE = "scheduleExpression";
+const _sET = "scheduleEndTime";
+const _sF = "sourceFields";
+const _sFC = "sourceFlowConfig";
+const _sFTD = "supportedFieldTypeDetails";
+const _sIFC = "s3InputFormatConfig";
+const _sIFT = "s3InputFileType";
+const _sK = "secretKey";
+const _sO = "supportedOperators";
+const _sOFC = "s3OutputFormatConfig";
+const _sOc = "scheduleOffset";
+const _sP = "sourceProperties";
+const _sR = "supportedRegions";
+const _sRHC = "successResponseHandlingConfig";
+const _sSF = "supportedSchedulingFrequencies";
+const _sST = "scheduleStartTime";
+const _sTT = "supportedTriggerTypes";
+const _sV = "schemaVersion";
+const _sVu = "supportedValues";
+const _sWO = "supportedWriteOperations";
+const _se = "server";
+const _sm = "smithy.ts.sdk.synthetic.com.amazonaws.appflow";
+const _st = "status";
+const _sta = "stage";
+const _t = "tasks";
+const _tC = "triggerConfig";
+const _tFS = "targetFileSize";
 const _tK = "tagKeys";
+const _tN = "tableName";
+const _tP = "tablePrefix";
+const _tPa = "taskProperties";
+const _tPr = "triggerProperties";
+const _tRO = "tableRegistrationOutput";
+const _tT = "triggerType";
+const _tTa = "taskType";
+const _tU = "tokenUrls";
+const _tUCP = "tokenUrlCustomProperties";
+const _tUo = "tokenUrl";
+const _ta = "tags";
+const _ti = "timezone";
+const _ty = "type";
+const _u = "username";
+const _uI = "userId";
+const _uPLFMAA = "usePrivateLinkForMetadataAndAuthorization";
+const _v = "v1";
+const _vRP = "valueRegexPattern";
+const _w = "warehouse";
+const _wN = "workgroupName";
+const _wOT = "writeOperationType";
+const n0 = "com.amazonaws.appflow";
+var AccessKeyId = [0, n0, _AKI, 8, 0];
+var AccessToken = [0, n0, _AT, 8, 0];
+var ApiKey = [0, n0, _AK, 8, 0];
+var ApiSecretKey = [0, n0, _ASK, 8, 0];
+var ClientCredentialsArn = [0, n0, _CCA, 8, 0];
+var ClientSecret = [0, n0, _CS, 8, 0];
+var CredentialsMapKey = [0, n0, _CMK, 8, 0];
+var CredentialsMapValue = [0, n0, _CMV, 8, 0];
+var JwtToken = [0, n0, _JT, 8, 0];
+var Password = [0, n0, _P, 8, 0];
+var SecretKey = [0, n0, _SK, 8, 0];
+var AccessDeniedException = [
+    -3,
+    n0,
+    _ADE,
+    {
+        [_e]: _c,
+        [_hE]: 403,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(AccessDeniedException, AccessDeniedException$1);
+var AggregationConfig = [3, n0, _AC, 0, [_aT, _tFS], [0, 1]];
+var AmplitudeConnectorProfileCredentials = [
+    3,
+    n0,
+    _ACPC,
+    0,
+    [_aK, _sK],
+    [
+        [() => ApiKey, 0],
+        [() => SecretKey, 0],
+    ],
+];
+var AmplitudeConnectorProfileProperties = [3, n0, _ACPP, 0, [], []];
+var AmplitudeMetadata = [3, n0, _AM, 0, [], []];
+var AmplitudeSourceProperties = [3, n0, _ASP, 0, [_o], [0]];
+var ApiKeyCredentials = [
+    3,
+    n0,
+    _AKC,
+    0,
+    [_aK, _aSK],
+    [
+        [() => ApiKey, 0],
+        [() => ApiSecretKey, 0],
+    ],
+];
+var AuthenticationConfig = [
+    3,
+    n0,
+    _ACu,
+    0,
+    [_iBAS, _iAKAS, _iOAS, _iCAS, _oAD, _cAC],
+    [2, 2, 2, 2, () => OAuth2Defaults, () => CustomAuthConfigList],
+];
+var AuthParameter = [
+    3,
+    n0,
+    _AP,
+    0,
+    [_k, _iR, _l, _d, _iSF, _cSV],
+    [0, 2, 0, 0, 2, 64 | 0],
+];
+var BasicAuthCredentials = [3, n0, _BAC, 0, [_u, _p], [0, [() => Password, 0]]];
+var CancelFlowExecutionsRequest = [3, n0, _CFER, 0, [_fN, _eI], [0, 64 | 0]];
+var CancelFlowExecutionsResponse = [3, n0, _CFERa, 0, [_iE], [64 | 0]];
+var ConflictException = [
+    -3,
+    n0,
+    _CE,
+    {
+        [_e]: _c,
+        [_hE]: 409,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ConflictException, ConflictException$1);
+var ConnectorAuthenticationException = [
+    -3,
+    n0,
+    _CAE,
+    {
+        [_e]: _c,
+        [_hE]: 401,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ConnectorAuthenticationException, ConnectorAuthenticationException$1);
+var ConnectorConfiguration = [
+    3,
+    n0,
+    _CC,
+    0,
+    [
+        _cUAS,
+        _cUAD,
+        _sDC,
+        _sSF,
+        _iPLE,
+        _iPLEUR,
+        _sTT,
+        _cM,
+        _cT,
+        _cL,
+        _cD,
+        _cO,
+        _cN,
+        _cV,
+        _cA,
+        _cMo,
+        _aC,
+        _cRS,
+        _sAV,
+        _sO,
+        _sWO,
+        _cPT,
+        _cPC,
+        _lURL,
+        _rA,
+        _rB,
+        _sDTT,
+        _sDTA,
+    ],
+    [
+        2,
+        2,
+        64 | 0,
+        64 | 0,
+        2,
+        2,
+        64 | 0,
+        () => ConnectorMetadata,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        64 | 0,
+        () => AuthenticationConfig,
+        () => ConnectorRuntimeSettingList,
+        64 | 0,
+        64 | 0,
+        64 | 0,
+        0,
+        () => ConnectorProvisioningConfig,
+        0,
+        4,
+        0,
+        64 | 0,
+        () => SupportedDataTransferApis,
+    ],
+];
+var ConnectorDetail = [
+    3,
+    n0,
+    _CD,
+    0,
+    [_cD, _cN, _cO, _cV, _aTp, _cT, _cL, _rA, _rB, _cPT, _cMo, _sDTT],
+    [0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 64 | 0, 64 | 0],
+];
+var ConnectorEntity = [3, n0, _CEo, 0, [_n, _l, _hNE], [0, 0, 2]];
+var ConnectorEntityField = [
+    3,
+    n0,
+    _CEF,
+    0,
+    [_i, _pI, _l, _iPK, _dV, _iD, _sFTD, _d, _sP, _dP, _cP],
+    [
+        0,
+        0,
+        0,
+        2,
+        0,
+        2,
+        () => SupportedFieldTypeDetails,
+        0,
+        () => SourceFieldProperties,
+        () => DestinationFieldProperties,
+        128 | 0,
+    ],
+];
+var ConnectorMetadata = [
+    3,
+    n0,
+    _CM,
+    0,
+    [_A, _D, _Dy, _GA, _IN, _M, _R, _S, _Sa, _SN, _Si, _Sl, _Sn, _T, _V, _Z, _EB, _U, _CP, _H, _SAPOD, _Pa],
+    [
+        () => AmplitudeMetadata,
+        () => DatadogMetadata,
+        () => DynatraceMetadata,
+        () => GoogleAnalyticsMetadata,
+        () => InforNexusMetadata,
+        () => MarketoMetadata,
+        () => RedshiftMetadata,
+        () => S3Metadata,
+        () => SalesforceMetadata,
+        () => ServiceNowMetadata,
+        () => SingularMetadata,
+        () => SlackMetadata,
+        () => SnowflakeMetadata,
+        () => TrendmicroMetadata,
+        () => VeevaMetadata,
+        () => ZendeskMetadata,
+        () => EventBridgeMetadata,
+        () => UpsolverMetadata,
+        () => CustomerProfilesMetadata,
+        () => HoneycodeMetadata,
+        () => SAPODataMetadata,
+        () => PardotMetadata,
+    ],
+];
+var ConnectorOAuthRequest = [3, n0, _COAR, 0, [_aCu, _rU], [0, 0]];
+var ConnectorOperator = [
+    3,
+    n0,
+    _CO,
+    0,
+    [_A, _D, _Dy, _GA, _IN, _M, _S, _Sa, _SN, _Si, _Sl, _T, _V, _Z, _SAPOD, _CCu, _Pa],
+    [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+];
+var ConnectorProfile = [
+    3,
+    n0,
+    _CPo,
+    0,
+    [_cPA, _cPN, _cT, _cL, _cMon, _cAr, _cPP, _cAre, _lUA, _pCPS],
+    [0, 0, 0, 0, 0, 0, () => ConnectorProfileProperties, 4, 4, () => PrivateConnectionProvisioningState],
+];
+var ConnectorProfileConfig = [
+    3,
+    n0,
+    _CPC,
+    0,
+    [_cPP, _cPCo],
+    [() => ConnectorProfileProperties, [() => ConnectorProfileCredentials, 0]],
+];
+var ConnectorProfileCredentials = [
+    3,
+    n0,
+    _CPCo,
+    0,
+    [_A, _D, _Dy, _GA, _H, _IN, _M, _R, _Sa, _SN, _Si, _Sl, _Sn, _T, _V, _Z, _SAPOD, _CCu, _Pa],
+    [
+        [() => AmplitudeConnectorProfileCredentials, 0],
+        [() => DatadogConnectorProfileCredentials, 0],
+        () => DynatraceConnectorProfileCredentials,
+        [() => GoogleAnalyticsConnectorProfileCredentials, 0],
+        [() => HoneycodeConnectorProfileCredentials, 0],
+        [() => InforNexusConnectorProfileCredentials, 0],
+        [() => MarketoConnectorProfileCredentials, 0],
+        [() => RedshiftConnectorProfileCredentials, 0],
+        [() => SalesforceConnectorProfileCredentials, 0],
+        [() => ServiceNowConnectorProfileCredentials, 0],
+        [() => SingularConnectorProfileCredentials, 0],
+        [() => SlackConnectorProfileCredentials, 0],
+        [() => SnowflakeConnectorProfileCredentials, 0],
+        [() => TrendmicroConnectorProfileCredentials, 0],
+        [() => VeevaConnectorProfileCredentials, 0],
+        [() => ZendeskConnectorProfileCredentials, 0],
+        [() => SAPODataConnectorProfileCredentials, 0],
+        [() => CustomConnectorProfileCredentials, 0],
+        [() => PardotConnectorProfileCredentials, 0],
+    ],
+];
+var ConnectorProfileProperties = [
+    3,
+    n0,
+    _CPP,
+    0,
+    [_A, _D, _Dy, _GA, _H, _IN, _M, _R, _Sa, _SN, _Si, _Sl, _Sn, _T, _V, _Z, _SAPOD, _CCu, _Pa],
+    [
+        () => AmplitudeConnectorProfileProperties,
+        () => DatadogConnectorProfileProperties,
+        () => DynatraceConnectorProfileProperties,
+        () => GoogleAnalyticsConnectorProfileProperties,
+        () => HoneycodeConnectorProfileProperties,
+        () => InforNexusConnectorProfileProperties,
+        () => MarketoConnectorProfileProperties,
+        () => RedshiftConnectorProfileProperties,
+        () => SalesforceConnectorProfileProperties,
+        () => ServiceNowConnectorProfileProperties,
+        () => SingularConnectorProfileProperties,
+        () => SlackConnectorProfileProperties,
+        () => SnowflakeConnectorProfileProperties,
+        () => TrendmicroConnectorProfileProperties,
+        () => VeevaConnectorProfileProperties,
+        () => ZendeskConnectorProfileProperties,
+        () => SAPODataConnectorProfileProperties,
+        () => CustomConnectorProfileProperties,
+        () => PardotConnectorProfileProperties,
+    ],
+];
+var ConnectorProvisioningConfig = [
+    3,
+    n0,
+    _CPCon,
+    0,
+    [_la],
+    [() => LambdaConnectorProvisioningConfig],
+];
+var ConnectorRuntimeSetting = [
+    3,
+    n0,
+    _CRS,
+    0,
+    [_k, _dT, _iR, _l, _d, _s, _cSVO],
+    [0, 0, 2, 0, 0, 0, 64 | 0],
+];
+var ConnectorServerException = [
+    -3,
+    n0,
+    _CSE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ConnectorServerException, ConnectorServerException$1);
+var CreateConnectorProfileRequest = [
+    3,
+    n0,
+    _CCPR,
+    0,
+    [_cPN, _kA, _cT, _cL, _cMon, _cPCon, _cTl],
+    [0, 0, 0, 0, 0, [() => ConnectorProfileConfig, 0], [0, 4]],
+];
+var CreateConnectorProfileResponse = [3, n0, _CCPRr, 0, [_cPA], [0]];
+var CreateFlowRequest = [
+    3,
+    n0,
+    _CFR,
+    0,
+    [_fN, _d, _kA, _tC, _sFC, _dFCL, _t, _ta, _mCC, _cTl],
+    [
+        0,
+        0,
+        0,
+        () => TriggerConfig,
+        () => SourceFlowConfig,
+        () => DestinationFlowConfigList,
+        () => Tasks,
+        128 | 0,
+        () => MetadataCatalogConfig,
+        [0, 4],
+    ],
+];
+var CreateFlowResponse = [3, n0, _CFRr, 0, [_fA, _fS], [0, 0]];
+var CustomAuthConfig = [3, n0, _CAC, 0, [_cAT, _aP], [0, () => AuthParameterList]];
+var CustomAuthCredentials = [
+    3,
+    n0,
+    _CACu,
+    0,
+    [_cAT, _cMr],
+    [0, [() => CredentialsMap, 0]],
+];
+var CustomConnectorDestinationProperties = [
+    3,
+    n0,
+    _CCDP,
+    0,
+    [_eN, _eHC, _wOT, _iFN, _cP],
+    [0, () => ErrorHandlingConfig, 0, 64 | 0, 128 | 0],
+];
+var CustomConnectorProfileCredentials = [
+    3,
+    n0,
+    _CCPC,
+    0,
+    [_aTu, _b, _oa, _aK, _cu],
+    [
+        0,
+        [() => BasicAuthCredentials, 0],
+        [() => OAuth2Credentials, 0],
+        [() => ApiKeyCredentials, 0],
+        [() => CustomAuthCredentials, 0],
+    ],
+];
+var CustomConnectorProfileProperties = [
+    3,
+    n0,
+    _CCPP,
+    0,
+    [_pP, _oAP],
+    [128 | 0, () => OAuth2Properties],
+];
+var CustomConnectorSourceProperties = [
+    3,
+    n0,
+    _CCSP,
+    0,
+    [_eN, _cP, _dTA],
+    [0, 128 | 0, () => DataTransferApi],
+];
+var CustomerProfilesDestinationProperties = [3, n0, _CPDP, 0, [_dN, _oTN], [0, 0]];
+var CustomerProfilesMetadata = [3, n0, _CPM, 0, [], []];
+var DatadogConnectorProfileCredentials = [
+    3,
+    n0,
+    _DCPC,
+    0,
+    [_aK, _aKp],
+    [[() => ApiKey, 0], 0],
+];
+var DatadogConnectorProfileProperties = [3, n0, _DCPP, 0, [_iU], [0]];
+var DatadogMetadata = [3, n0, _DM, 0, [], []];
+var DatadogSourceProperties = [3, n0, _DSP, 0, [_o], [0]];
+var DataTransferApi = [3, n0, _DTA, 0, [_N, _Ty], [0, 0]];
+var DeleteConnectorProfileRequest = [3, n0, _DCPR, 0, [_cPN, _fD], [0, 2]];
+var DeleteConnectorProfileResponse = [3, n0, _DCPRe, 0, [], []];
+var DeleteFlowRequest = [3, n0, _DFR, 0, [_fN, _fD], [0, 2]];
+var DeleteFlowResponse = [3, n0, _DFRe, 0, [], []];
+var DescribeConnectorEntityRequest = [
+    3,
+    n0,
+    _DCER,
+    0,
+    [_cEN, _cT, _cPN, _aV],
+    [0, 0, 0, 0],
+];
+var DescribeConnectorEntityResponse = [
+    3,
+    n0,
+    _DCERe,
+    0,
+    [_cEF],
+    [() => ConnectorEntityFieldList],
+];
+var DescribeConnectorProfilesRequest = [
+    3,
+    n0,
+    _DCPRes,
+    0,
+    [_cPNo, _cT, _cL, _mR, _nT],
+    [64 | 0, 0, 0, 1, 0],
+];
+var DescribeConnectorProfilesResponse = [
+    3,
+    n0,
+    _DCPResc,
+    0,
+    [_cPD, _nT],
+    [() => ConnectorProfileDetailList, 0],
+];
+var DescribeConnectorRequest = [3, n0, _DCR, 0, [_cT, _cL], [0, 0]];
+var DescribeConnectorResponse = [3, n0, _DCRe, 0, [_cC], [() => ConnectorConfiguration]];
+var DescribeConnectorsRequest = [3, n0, _DCRes, 0, [_cTo, _mR, _nT], [64 | 0, 1, 0]];
+var DescribeConnectorsResponse = [
+    3,
+    n0,
+    _DCResc,
+    0,
+    [_cCo, _co, _nT],
+    [() => ConnectorConfigurationsMap, () => ConnectorList, 0],
+];
+var DescribeFlowExecutionRecordsRequest = [3, n0, _DFERR, 0, [_fN, _mR, _nT], [0, 1, 0]];
+var DescribeFlowExecutionRecordsResponse = [
+    3,
+    n0,
+    _DFERRe,
+    0,
+    [_fE, _nT],
+    [() => FlowExecutionList, 0],
+];
+var DescribeFlowRequest = [3, n0, _DFRes, 0, [_fN], [0]];
+var DescribeFlowResponse = [
+    3,
+    n0,
+    _DFResc,
+    0,
+    [_fA, _d, _fN, _kA, _fS, _fSM, _sFC, _dFCL, _lRED, _tC, _t, _cAre, _lUA, _cB, _lUB, _ta, _mCC, _lRMCD, _sV],
+    [
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        () => SourceFlowConfig,
+        () => DestinationFlowConfigList,
+        () => ExecutionDetails,
+        () => TriggerConfig,
+        () => Tasks,
+        4,
+        4,
+        0,
+        0,
+        128 | 0,
+        () => MetadataCatalogConfig,
+        () => MetadataCatalogDetails,
+        1,
+    ],
+];
+var DestinationConnectorProperties = [
+    3,
+    n0,
+    _DCP,
+    0,
+    [_R, _S, _Sa, _Sn, _EB, _LM, _U, _H, _CP, _Z, _M, _CCu, _SAPOD],
+    [
+        () => RedshiftDestinationProperties,
+        () => S3DestinationProperties,
+        () => SalesforceDestinationProperties,
+        () => SnowflakeDestinationProperties,
+        () => EventBridgeDestinationProperties,
+        () => LookoutMetricsDestinationProperties,
+        () => UpsolverDestinationProperties,
+        () => HoneycodeDestinationProperties,
+        () => CustomerProfilesDestinationProperties,
+        () => ZendeskDestinationProperties,
+        () => MarketoDestinationProperties,
+        () => CustomConnectorDestinationProperties,
+        () => SAPODataDestinationProperties,
+    ],
+];
+var DestinationFieldProperties = [
+    3,
+    n0,
+    _DFP,
+    0,
+    [_iC, _iN, _iUs, _iUsp, _iDOC, _sWO],
+    [2, 2, 2, 2, 2, 64 | 0],
+];
+var DestinationFlowConfig = [
+    3,
+    n0,
+    _DFC,
+    0,
+    [_cT, _aV, _cPN, _dCP],
+    [0, 0, 0, () => DestinationConnectorProperties],
+];
+var DynatraceConnectorProfileCredentials = [3, n0, _DCPCy, 0, [_aTpi], [0]];
+var DynatraceConnectorProfileProperties = [3, n0, _DCPPy, 0, [_iU], [0]];
+var DynatraceMetadata = [3, n0, _DMy, 0, [], []];
+var DynatraceSourceProperties = [3, n0, _DSPy, 0, [_o], [0]];
+var ErrorHandlingConfig = [3, n0, _EHC, 0, [_fOFDE, _bP, _bN], [2, 0, 0]];
+var ErrorInfo = [3, n0, _EI, 0, [_pFC, _eM], [1, 0]];
+var EventBridgeDestinationProperties = [
+    3,
+    n0,
+    _EBDP,
+    0,
+    [_o, _eHC],
+    [0, () => ErrorHandlingConfig],
+];
+var EventBridgeMetadata = [3, n0, _EBM, 0, [], []];
+var ExecutionDetails = [3, n0, _ED, 0, [_mREM, _mRET, _mRES], [0, 4, 0]];
+var ExecutionRecord = [
+    3,
+    n0,
+    _ER,
+    0,
+    [_eIx, _eS, _eR, _sA, _lUA, _dPST, _dPET, _mCD],
+    [0, 0, () => ExecutionResult, 4, 4, 4, 4, () => MetadataCatalogDetails],
+];
+var ExecutionResult = [
+    3,
+    n0,
+    _ERx,
+    0,
+    [_eIr, _bPy, _bW, _rP, _nPP, _mPS],
+    [() => ErrorInfo, 1, 1, 1, 1, 1],
+];
+var FieldTypeDetails = [
+    3,
+    n0,
+    _FTD,
+    0,
+    [_fT, _fO, _sVu, _vRP, _sDF, _fVR, _fLR],
+    [0, 64 | 0, 64 | 0, 0, 0, () => Range, () => Range],
+];
+var FlowDefinition = [
+    3,
+    n0,
+    _FD,
+    0,
+    [_fA, _d, _fN, _fS, _sCT, _sCL, _dCT, _dCL, _tT, _cAre, _lUA, _cB, _lUB, _ta, _lRED],
+    [0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 4, 0, 0, 128 | 0, () => ExecutionDetails],
+];
+var GlueDataCatalogConfig = [3, n0, _GDCC, 0, [_rAo, _dNa, _tP], [0, 0, 0]];
+var GoogleAnalyticsConnectorProfileCredentials = [
+    3,
+    n0,
+    _GACPC,
+    0,
+    [_cI, _cS, _aTc, _rT, _oAR],
+    [0, [() => ClientSecret, 0], [() => AccessToken, 0], 0, () => ConnectorOAuthRequest],
+];
+var GoogleAnalyticsConnectorProfileProperties = [3, n0, _GACPP, 0, [], []];
+var GoogleAnalyticsMetadata = [3, n0, _GAM, 0, [_oAS], [64 | 0]];
+var GoogleAnalyticsSourceProperties = [3, n0, _GASP, 0, [_o], [0]];
+var HoneycodeConnectorProfileCredentials = [
+    3,
+    n0,
+    _HCPC,
+    0,
+    [_aTc, _rT, _oAR],
+    [[() => AccessToken, 0], 0, () => ConnectorOAuthRequest],
+];
+var HoneycodeConnectorProfileProperties = [3, n0, _HCPP, 0, [], []];
+var HoneycodeDestinationProperties = [
+    3,
+    n0,
+    _HDP,
+    0,
+    [_o, _eHC],
+    [0, () => ErrorHandlingConfig],
+];
+var HoneycodeMetadata = [3, n0, _HM, 0, [_oAS], [64 | 0]];
+var IncrementalPullConfig = [3, n0, _IPC, 0, [_dTFN], [0]];
+var InforNexusConnectorProfileCredentials = [
+    3,
+    n0,
+    _INCPC,
+    0,
+    [_aKI, _uI, _sAK, _da],
+    [[() => AccessKeyId, 0], 0, 0, 0],
+];
+var InforNexusConnectorProfileProperties = [3, n0, _INCPP, 0, [_iU], [0]];
+var InforNexusMetadata = [3, n0, _INM, 0, [], []];
+var InforNexusSourceProperties = [3, n0, _INSP, 0, [_o], [0]];
+var InternalServerException = [
+    -3,
+    n0,
+    _ISE,
+    {
+        [_e]: _se,
+        [_hE]: 500,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(InternalServerException, InternalServerException$1);
+var LambdaConnectorProvisioningConfig = [3, n0, _LCPC, 0, [_lA], [0]];
+var ListConnectorEntitiesRequest = [
+    3,
+    n0,
+    _LCER,
+    0,
+    [_cPN, _cT, _eP, _aV, _mR, _nT],
+    [0, 0, 0, 0, 1, 0],
+];
+var ListConnectorEntitiesResponse = [
+    3,
+    n0,
+    _LCERi,
+    0,
+    [_cEM, _nT],
+    [() => ConnectorEntityMap, 0],
+];
+var ListConnectorsRequest = [3, n0, _LCR, 0, [_mR, _nT], [1, 0]];
+var ListConnectorsResponse = [3, n0, _LCRi, 0, [_co, _nT], [() => ConnectorList, 0]];
+var ListFlowsRequest = [3, n0, _LFR, 0, [_mR, _nT], [1, 0]];
+var ListFlowsResponse = [3, n0, _LFRi, 0, [_f, _nT], [() => FlowList, 0]];
+var ListTagsForResourceRequest = [3, n0, _LTFRR, 0, [_rAe], [[0, 1]]];
+var ListTagsForResourceResponse = [3, n0, _LTFRRi, 0, [_ta], [128 | 0]];
+var LookoutMetricsDestinationProperties = [3, n0, _LMDP, 0, [], []];
+var MarketoConnectorProfileCredentials = [
+    3,
+    n0,
+    _MCPC,
+    0,
+    [_cI, _cS, _aTc, _oAR],
+    [0, [() => ClientSecret, 0], [() => AccessToken, 0], () => ConnectorOAuthRequest],
+];
+var MarketoConnectorProfileProperties = [3, n0, _MCPP, 0, [_iU], [0]];
+var MarketoDestinationProperties = [
+    3,
+    n0,
+    _MDP,
+    0,
+    [_o, _eHC],
+    [0, () => ErrorHandlingConfig],
+];
+var MarketoMetadata = [3, n0, _MM, 0, [], []];
+var MarketoSourceProperties = [3, n0, _MSP, 0, [_o], [0]];
+var MetadataCatalogConfig = [3, n0, _MCC, 0, [_gDC], [() => GlueDataCatalogConfig]];
+var MetadataCatalogDetail = [
+    3,
+    n0,
+    _MCD,
+    0,
+    [_cTa, _tN, _tRO, _pRO],
+    [0, 0, () => RegistrationOutput, () => RegistrationOutput],
+];
+var OAuth2Credentials = [
+    3,
+    n0,
+    _OAC,
+    0,
+    [_cI, _cS, _aTc, _rT, _oAR],
+    [0, [() => ClientSecret, 0], [() => AccessToken, 0], 0, () => ConnectorOAuthRequest],
+];
+var OAuth2CustomParameter = [
+    3,
+    n0,
+    _OACP,
+    0,
+    [_k, _iR, _l, _d, _iSF, _cSV, _ty],
+    [0, 2, 0, 0, 2, 64 | 0, 0],
+];
+var OAuth2Defaults = [
+    3,
+    n0,
+    _OAD,
+    0,
+    [_oS, _tU, _aCU, _oGTS, _oCP],
+    [64 | 0, 64 | 0, 64 | 0, 64 | 0, () => OAuth2CustomPropertiesList],
+];
+var OAuth2Properties = [3, n0, _OAP, 0, [_tUo, _oAGT, _tUCP], [0, 0, 128 | 0]];
+var OAuthCredentials = [
+    3,
+    n0,
+    _OACu,
+    0,
+    [_cI, _cS, _aTc, _rT, _oAR],
+    [0, [() => ClientSecret, 0], [() => AccessToken, 0], 0, () => ConnectorOAuthRequest],
+];
+var OAuthProperties = [3, n0, _OAPu, 0, [_tUo, _aCUu, _oAS], [0, 0, 64 | 0]];
+var PardotConnectorProfileCredentials = [
+    3,
+    n0,
+    _PCPC,
+    0,
+    [_aTc, _rT, _oAR, _cCA],
+    [[() => AccessToken, 0], 0, () => ConnectorOAuthRequest, [() => ClientCredentialsArn, 0]],
+];
+var PardotConnectorProfileProperties = [3, n0, _PCPP, 0, [_iU, _iSE, _bUI], [0, 2, 0]];
+var PardotMetadata = [3, n0, _PM, 0, [], []];
+var PardotSourceProperties = [3, n0, _PSP, 0, [_o], [0]];
+var PrefixConfig = [3, n0, _PC, 0, [_pT, _pF, _pPH], [0, 0, 64 | 0]];
+var PrivateConnectionProvisioningState = [3, n0, _PCPS, 0, [_st, _fM, _fC], [0, 0, 0]];
+var Range = [3, n0, _Ra, 0, [_ma, _mi], [1, 1]];
+var RedshiftConnectorProfileCredentials = [
+    3,
+    n0,
+    _RCPC,
+    0,
+    [_u, _p],
+    [0, [() => Password, 0]],
+];
+var RedshiftConnectorProfileProperties = [
+    3,
+    n0,
+    _RCPP,
+    0,
+    [_dU, _bN, _bP, _rAo, _dARA, _iRS, _cIl, _wN, _dNa],
+    [0, 0, 0, 0, 0, 2, 0, 0, 0],
+];
+var RedshiftDestinationProperties = [
+    3,
+    n0,
+    _RDP,
+    0,
+    [_o, _iBN, _bP, _eHC],
+    [0, 0, 0, () => ErrorHandlingConfig],
+];
+var RedshiftMetadata = [3, n0, _RM, 0, [], []];
+var RegisterConnectorRequest = [
+    3,
+    n0,
+    _RCR,
+    0,
+    [_cL, _d, _cPT, _cPC, _cTl],
+    [0, 0, 0, () => ConnectorProvisioningConfig, [0, 4]],
+];
+var RegisterConnectorResponse = [3, n0, _RCRe, 0, [_cA], [0]];
+var RegistrationOutput = [3, n0, _RO, 0, [_m, _r, _st], [0, 0, 0]];
+var ResetConnectorMetadataCacheRequest = [
+    3,
+    n0,
+    _RCMCR,
+    0,
+    [_cPN, _cT, _cEN, _eP, _aV],
+    [0, 0, 0, 0, 0],
+];
+var ResetConnectorMetadataCacheResponse = [3, n0, _RCMCRe, 0, [], []];
+var ResourceNotFoundException = [
+    -3,
+    n0,
+    _RNFE,
+    {
+        [_e]: _c,
+        [_hE]: 404,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ResourceNotFoundException, ResourceNotFoundException$1);
+var S3DestinationProperties = [
+    3,
+    n0,
+    _SDP,
+    0,
+    [_bN, _bP, _sOFC],
+    [0, 0, () => S3OutputFormatConfig],
+];
+var S3InputFormatConfig = [3, n0, _SIFC, 0, [_sIFT], [0]];
+var S3Metadata = [3, n0, _SM, 0, [], []];
+var S3OutputFormatConfig = [
+    3,
+    n0,
+    _SOFC,
+    0,
+    [_fTi, _pC, _aCg, _pSDT],
+    [0, () => PrefixConfig, () => AggregationConfig, 2],
+];
+var S3SourceProperties = [
+    3,
+    n0,
+    _SSP,
+    0,
+    [_bN, _bP, _sIFC],
+    [0, 0, () => S3InputFormatConfig],
+];
+var SalesforceConnectorProfileCredentials = [
+    3,
+    n0,
+    _SCPC,
+    0,
+    [_aTc, _rT, _oAR, _cCA, _oAGT, _jT],
+    [[() => AccessToken, 0], 0, () => ConnectorOAuthRequest, [() => ClientCredentialsArn, 0], 0, [() => JwtToken, 0]],
+];
+var SalesforceConnectorProfileProperties = [
+    3,
+    n0,
+    _SCPP,
+    0,
+    [_iU, _iSE, _uPLFMAA],
+    [0, 2, 2],
+];
+var SalesforceDestinationProperties = [
+    3,
+    n0,
+    _SDPa,
+    0,
+    [_o, _iFN, _eHC, _wOT, _dTA],
+    [0, 64 | 0, () => ErrorHandlingConfig, 0, 0],
+];
+var SalesforceMetadata = [3, n0, _SMa, 0, [_oAS, _dTAa, _oGTS], [64 | 0, 64 | 0, 64 | 0]];
+var SalesforceSourceProperties = [3, n0, _SSPa, 0, [_o, _eDFU, _iDR, _dTA], [0, 2, 2, 0]];
+var SAPODataConnectorProfileCredentials = [
+    3,
+    n0,
+    _SAPODCPC,
+    0,
+    [_bAC, _oAC],
+    [
+        [() => BasicAuthCredentials, 0],
+        [() => OAuthCredentials, 0],
+    ],
+];
+var SAPODataConnectorProfileProperties = [
+    3,
+    n0,
+    _SAPODCPP,
+    0,
+    [_aHU, _aSP, _pN, _cNl, _lL, _pLSN, _oAPu, _dSSO],
+    [0, 0, 1, 0, 0, 0, () => OAuthProperties, 2],
+];
+var SAPODataDestinationProperties = [
+    3,
+    n0,
+    _SAPODDP,
+    0,
+    [_oP, _sRHC, _iFN, _eHC, _wOT],
+    [0, () => SuccessResponseHandlingConfig, 64 | 0, () => ErrorHandlingConfig, 0],
+];
+var SAPODataMetadata = [3, n0, _SAPODM, 0, [], []];
+var SAPODataPaginationConfig = [3, n0, _SAPODPC, 0, [_mPS], [1]];
+var SAPODataParallelismConfig = [3, n0, _SAPODPCa, 0, [_mP], [1]];
+var SAPODataSourceProperties = [
+    3,
+    n0,
+    _SAPODSP,
+    0,
+    [_oP, _pCa, _pCag],
+    [0, () => SAPODataParallelismConfig, () => SAPODataPaginationConfig],
+];
+var ScheduledTriggerProperties = [
+    3,
+    n0,
+    _STP,
+    0,
+    [_sE, _dPM, _sST, _sET, _ti, _sOc, _fEF, _fEDT],
+    [0, 0, 4, 4, 0, 1, 4, 1],
+];
+var ServiceNowConnectorProfileCredentials = [
+    3,
+    n0,
+    _SNCPC,
+    0,
+    [_u, _p, _oACu],
+    [0, [() => Password, 0], [() => OAuth2Credentials, 0]],
+];
+var ServiceNowConnectorProfileProperties = [3, n0, _SNCPP, 0, [_iU], [0]];
+var ServiceNowMetadata = [3, n0, _SNM, 0, [], []];
+var ServiceNowSourceProperties = [3, n0, _SNSP, 0, [_o], [0]];
+var ServiceQuotaExceededException = [
+    -3,
+    n0,
+    _SQEE,
+    {
+        [_e]: _c,
+        [_hE]: 402,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ServiceQuotaExceededException, ServiceQuotaExceededException$1);
+var SingularConnectorProfileCredentials = [3, n0, _SCPCi, 0, [_aK], [[() => ApiKey, 0]]];
+var SingularConnectorProfileProperties = [3, n0, _SCPPi, 0, [], []];
+var SingularMetadata = [3, n0, _SMi, 0, [], []];
+var SingularSourceProperties = [3, n0, _SSPi, 0, [_o], [0]];
+var SlackConnectorProfileCredentials = [
+    3,
+    n0,
+    _SCPCl,
+    0,
+    [_cI, _cS, _aTc, _oAR],
+    [0, [() => ClientSecret, 0], [() => AccessToken, 0], () => ConnectorOAuthRequest],
+];
+var SlackConnectorProfileProperties = [3, n0, _SCPPl, 0, [_iU], [0]];
+var SlackMetadata = [3, n0, _SMl, 0, [_oAS], [64 | 0]];
+var SlackSourceProperties = [3, n0, _SSPl, 0, [_o], [0]];
+var SnowflakeConnectorProfileCredentials = [
+    3,
+    n0,
+    _SCPCn,
+    0,
+    [_u, _p],
+    [0, [() => Password, 0]],
+];
+var SnowflakeConnectorProfileProperties = [
+    3,
+    n0,
+    _SCPPn,
+    0,
+    [_w, _sta, _bN, _bP, _pLSN, _aN, _re],
+    [0, 0, 0, 0, 0, 0, 0],
+];
+var SnowflakeDestinationProperties = [
+    3,
+    n0,
+    _SDPn,
+    0,
+    [_o, _iBN, _bP, _eHC],
+    [0, 0, 0, () => ErrorHandlingConfig],
+];
+var SnowflakeMetadata = [3, n0, _SMn, 0, [_sR], [64 | 0]];
+var SourceConnectorProperties = [
+    3,
+    n0,
+    _SCP,
+    0,
+    [_A, _D, _Dy, _GA, _IN, _M, _S, _Sa, _SN, _Si, _Sl, _T, _V, _Z, _SAPOD, _CCu, _Pa],
+    [
+        () => AmplitudeSourceProperties,
+        () => DatadogSourceProperties,
+        () => DynatraceSourceProperties,
+        () => GoogleAnalyticsSourceProperties,
+        () => InforNexusSourceProperties,
+        () => MarketoSourceProperties,
+        () => S3SourceProperties,
+        () => SalesforceSourceProperties,
+        () => ServiceNowSourceProperties,
+        () => SingularSourceProperties,
+        () => SlackSourceProperties,
+        () => TrendmicroSourceProperties,
+        () => VeevaSourceProperties,
+        () => ZendeskSourceProperties,
+        () => SAPODataSourceProperties,
+        () => CustomConnectorSourceProperties,
+        () => PardotSourceProperties,
+    ],
+];
+var SourceFieldProperties = [3, n0, _SFP, 0, [_iRs, _iQ, _iTFFIQ], [2, 2, 2]];
+var SourceFlowConfig = [
+    3,
+    n0,
+    _SFC,
+    0,
+    [_cT, _aV, _cPN, _sCP, _iPC],
+    [0, 0, 0, () => SourceConnectorProperties, () => IncrementalPullConfig],
+];
+var StartFlowRequest = [3, n0, _SFR, 0, [_fN, _cTl], [0, [0, 4]]];
+var StartFlowResponse = [3, n0, _SFRt, 0, [_fA, _fS, _eIx], [0, 0, 0]];
+var StopFlowRequest = [3, n0, _SFRto, 0, [_fN], [0]];
+var StopFlowResponse = [3, n0, _SFRtop, 0, [_fA, _fS], [0, 0]];
+var SuccessResponseHandlingConfig = [3, n0, _SRHC, 0, [_bP, _bN], [0, 0]];
+var SupportedFieldTypeDetails = [3, n0, _SFTD, 0, [_v], [() => FieldTypeDetails]];
+var TagResourceRequest = [3, n0, _TRR, 0, [_rAe, _ta], [[0, 1], 128 | 0]];
+var TagResourceResponse = [3, n0, _TRRa, 0, [], []];
+var Task = [
+    3,
+    n0,
+    _Ta,
+    0,
+    [_sF, _cOo, _dF, _tTa, _tPa],
+    [64 | 0, () => ConnectorOperator, 0, 0, 128 | 0],
+];
+var ThrottlingException = [
+    -3,
+    n0,
+    _TE,
+    {
+        [_e]: _c,
+        [_hE]: 429,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ThrottlingException, ThrottlingException$1);
+var TrendmicroConnectorProfileCredentials = [
+    3,
+    n0,
+    _TCPC,
+    0,
+    [_aSK],
+    [[() => ApiSecretKey, 0]],
+];
+var TrendmicroConnectorProfileProperties = [3, n0, _TCPP, 0, [], []];
+var TrendmicroMetadata = [3, n0, _TM, 0, [], []];
+var TrendmicroSourceProperties = [3, n0, _TSP, 0, [_o], [0]];
+var TriggerConfig = [3, n0, _TC, 0, [_tT, _tPr], [0, () => TriggerProperties]];
+var TriggerProperties = [3, n0, _TP, 0, [_Sc], [() => ScheduledTriggerProperties]];
+var UnregisterConnectorRequest = [3, n0, _UCR, 0, [_cL, _fD], [0, 2]];
+var UnregisterConnectorResponse = [3, n0, _UCRn, 0, [], []];
+var UnsupportedOperationException = [
+    -3,
+    n0,
+    _UOE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(UnsupportedOperationException, UnsupportedOperationException$1);
+var UntagResourceRequest = [
+    3,
+    n0,
+    _URR,
+    0,
+    [_rAe, _tK],
+    [
+        [0, 1],
+        [
+            64 | 0,
+            {
+                [_hQ]: _tK,
+            },
+        ],
+    ],
+];
+var UntagResourceResponse = [3, n0, _URRn, 0, [], []];
+var UpdateConnectorProfileRequest = [
+    3,
+    n0,
+    _UCPR,
+    0,
+    [_cPN, _cMon, _cPCon, _cTl],
+    [0, 0, [() => ConnectorProfileConfig, 0], [0, 4]],
+];
+var UpdateConnectorProfileResponse = [3, n0, _UCPRp, 0, [_cPA], [0]];
+var UpdateConnectorRegistrationRequest = [
+    3,
+    n0,
+    _UCRR,
+    0,
+    [_cL, _d, _cPC, _cTl],
+    [0, 0, () => ConnectorProvisioningConfig, [0, 4]],
+];
+var UpdateConnectorRegistrationResponse = [3, n0, _UCRRp, 0, [_cA], [0]];
+var UpdateFlowRequest = [
+    3,
+    n0,
+    _UFR,
+    0,
+    [_fN, _d, _tC, _sFC, _dFCL, _t, _mCC, _cTl],
+    [
+        0,
+        0,
+        () => TriggerConfig,
+        () => SourceFlowConfig,
+        () => DestinationFlowConfigList,
+        () => Tasks,
+        () => MetadataCatalogConfig,
+        [0, 4],
+    ],
+];
+var UpdateFlowResponse = [3, n0, _UFRp, 0, [_fS], [0]];
+var UpsolverDestinationProperties = [
+    3,
+    n0,
+    _UDP,
+    0,
+    [_bN, _bP, _sOFC],
+    [0, 0, () => UpsolverS3OutputFormatConfig],
+];
+var UpsolverMetadata = [3, n0, _UM, 0, [], []];
+var UpsolverS3OutputFormatConfig = [
+    3,
+    n0,
+    _USOFC,
+    0,
+    [_fTi, _pC, _aCg],
+    [0, () => PrefixConfig, () => AggregationConfig],
+];
+var ValidationException = [
+    -3,
+    n0,
+    _VE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ValidationException, ValidationException$1);
+var VeevaConnectorProfileCredentials = [
+    3,
+    n0,
+    _VCPC,
+    0,
+    [_u, _p],
+    [0, [() => Password, 0]],
+];
+var VeevaConnectorProfileProperties = [3, n0, _VCPP, 0, [_iU], [0]];
+var VeevaMetadata = [3, n0, _VM, 0, [], []];
+var VeevaSourceProperties = [
+    3,
+    n0,
+    _VSP,
+    0,
+    [_o, _dTo, _iSFn, _iRn, _iAV],
+    [0, 0, 2, 2, 2],
+];
+var ZendeskConnectorProfileCredentials = [
+    3,
+    n0,
+    _ZCPC,
+    0,
+    [_cI, _cS, _aTc, _oAR],
+    [0, [() => ClientSecret, 0], [() => AccessToken, 0], () => ConnectorOAuthRequest],
+];
+var ZendeskConnectorProfileProperties = [3, n0, _ZCPP, 0, [_iU], [0]];
+var ZendeskDestinationProperties = [
+    3,
+    n0,
+    _ZDP,
+    0,
+    [_o, _iFN, _eHC, _wOT],
+    [0, 64 | 0, () => ErrorHandlingConfig, 0],
+];
+var ZendeskMetadata = [3, n0, _ZM, 0, [_oAS], [64 | 0]];
+var ZendeskSourceProperties = [3, n0, _ZSP, 0, [_o], [0]];
+var AppflowServiceException = [-3, _sm, "AppflowServiceException", 0, [], []];
+schema.TypeRegistry.for(_sm).registerError(AppflowServiceException, AppflowServiceException$1);
+var AuthParameterList = [1, n0, _APL, 0, () => AuthParameter];
+var ConnectorEntityFieldList = [1, n0, _CEFL, 0, () => ConnectorEntityField];
+var ConnectorEntityList = [1, n0, _CEL, 0, () => ConnectorEntity];
+var ConnectorList = [1, n0, _CL, 0, () => ConnectorDetail];
+var ConnectorProfileDetailList = [1, n0, _CPDL, 0, () => ConnectorProfile];
+var ConnectorRuntimeSettingList = [1, n0, _CRSL, 0, () => ConnectorRuntimeSetting];
+var CustomAuthConfigList = [1, n0, _CACL, 0, () => CustomAuthConfig];
+var DestinationFlowConfigList = [1, n0, _DFCL, 0, () => DestinationFlowConfig];
+var FlowExecutionList = [1, n0, _FEL, 0, () => ExecutionRecord];
+var FlowList = [1, n0, _FL, 0, () => FlowDefinition];
+var MetadataCatalogDetails = [1, n0, _MCDe, 0, () => MetadataCatalogDetail];
+var OAuth2CustomPropertiesList = [1, n0, _OACPL, 0, () => OAuth2CustomParameter];
+var SupportedDataTransferApis = [1, n0, _SDTA, 0, () => DataTransferApi];
+var Tasks = [1, n0, _Tas, 0, () => Task];
+var ConnectorConfigurationsMap = [2, n0, _CCM, 0, 0, () => ConnectorConfiguration];
+var ConnectorEntityMap = [2, n0, _CEM, 0, 0, () => ConnectorEntityList];
+var CredentialsMap = [
+    2,
+    n0,
+    _CMr,
+    0,
+    [() => CredentialsMapKey, 0],
+    [() => CredentialsMapValue, 0],
+];
+var CancelFlowExecutions = [
+    9,
+    n0,
+    _CFE,
+    {
+        [_h]: ["POST", "/cancel-flow-executions", 200],
+    },
+    () => CancelFlowExecutionsRequest,
+    () => CancelFlowExecutionsResponse,
+];
+var CreateConnectorProfile = [
+    9,
+    n0,
+    _CCP,
+    {
+        [_h]: ["POST", "/create-connector-profile", 200],
+    },
+    () => CreateConnectorProfileRequest,
+    () => CreateConnectorProfileResponse,
+];
+var CreateFlow = [
+    9,
+    n0,
+    _CF,
+    {
+        [_h]: ["POST", "/create-flow", 200],
+    },
+    () => CreateFlowRequest,
+    () => CreateFlowResponse,
+];
+var DeleteConnectorProfile = [
+    9,
+    n0,
+    _DCPe,
+    {
+        [_h]: ["POST", "/delete-connector-profile", 200],
+    },
+    () => DeleteConnectorProfileRequest,
+    () => DeleteConnectorProfileResponse,
+];
+var DeleteFlow = [
+    9,
+    n0,
+    _DF,
+    {
+        [_h]: ["POST", "/delete-flow", 200],
+    },
+    () => DeleteFlowRequest,
+    () => DeleteFlowResponse,
+];
+var DescribeConnector = [
+    9,
+    n0,
+    _DC,
+    {
+        [_h]: ["POST", "/describe-connector", 200],
+    },
+    () => DescribeConnectorRequest,
+    () => DescribeConnectorResponse,
+];
+var DescribeConnectorEntity = [
+    9,
+    n0,
+    _DCE,
+    {
+        [_h]: ["POST", "/describe-connector-entity", 200],
+    },
+    () => DescribeConnectorEntityRequest,
+    () => DescribeConnectorEntityResponse,
+];
+var DescribeConnectorProfiles = [
+    9,
+    n0,
+    _DCPes,
+    {
+        [_h]: ["POST", "/describe-connector-profiles", 200],
+    },
+    () => DescribeConnectorProfilesRequest,
+    () => DescribeConnectorProfilesResponse,
+];
+var DescribeConnectors = [
+    9,
+    n0,
+    _DCe,
+    {
+        [_h]: ["POST", "/describe-connectors", 200],
+    },
+    () => DescribeConnectorsRequest,
+    () => DescribeConnectorsResponse,
+];
+var DescribeFlow = [
+    9,
+    n0,
+    _DFe,
+    {
+        [_h]: ["POST", "/describe-flow", 200],
+    },
+    () => DescribeFlowRequest,
+    () => DescribeFlowResponse,
+];
+var DescribeFlowExecutionRecords = [
+    9,
+    n0,
+    _DFER,
+    {
+        [_h]: ["POST", "/describe-flow-execution-records", 200],
+    },
+    () => DescribeFlowExecutionRecordsRequest,
+    () => DescribeFlowExecutionRecordsResponse,
+];
+var ListConnectorEntities = [
+    9,
+    n0,
+    _LCE,
+    {
+        [_h]: ["POST", "/list-connector-entities", 200],
+    },
+    () => ListConnectorEntitiesRequest,
+    () => ListConnectorEntitiesResponse,
+];
+var ListConnectors = [
+    9,
+    n0,
+    _LC,
+    {
+        [_h]: ["POST", "/list-connectors", 200],
+    },
+    () => ListConnectorsRequest,
+    () => ListConnectorsResponse,
+];
+var ListFlows = [
+    9,
+    n0,
+    _LF,
+    {
+        [_h]: ["POST", "/list-flows", 200],
+    },
+    () => ListFlowsRequest,
+    () => ListFlowsResponse,
+];
+var ListTagsForResource = [
+    9,
+    n0,
+    _LTFR,
+    {
+        [_h]: ["GET", "/tags/{resourceArn}", 200],
+    },
+    () => ListTagsForResourceRequest,
+    () => ListTagsForResourceResponse,
+];
+var RegisterConnector = [
+    9,
+    n0,
+    _RC,
+    {
+        [_h]: ["POST", "/register-connector", 200],
+    },
+    () => RegisterConnectorRequest,
+    () => RegisterConnectorResponse,
+];
+var ResetConnectorMetadataCache = [
+    9,
+    n0,
+    _RCMC,
+    {
+        [_h]: ["POST", "/reset-connector-metadata-cache", 200],
+    },
+    () => ResetConnectorMetadataCacheRequest,
+    () => ResetConnectorMetadataCacheResponse,
+];
+var StartFlow = [
+    9,
+    n0,
+    _SF,
+    {
+        [_h]: ["POST", "/start-flow", 200],
+    },
+    () => StartFlowRequest,
+    () => StartFlowResponse,
+];
+var StopFlow = [
+    9,
+    n0,
+    _SFt,
+    {
+        [_h]: ["POST", "/stop-flow", 200],
+    },
+    () => StopFlowRequest,
+    () => StopFlowResponse,
+];
+var TagResource = [
+    9,
+    n0,
+    _TR,
+    {
+        [_h]: ["POST", "/tags/{resourceArn}", 200],
+    },
+    () => TagResourceRequest,
+    () => TagResourceResponse,
+];
+var UnregisterConnector = [
+    9,
+    n0,
+    _UC,
+    {
+        [_h]: ["POST", "/unregister-connector", 200],
+    },
+    () => UnregisterConnectorRequest,
+    () => UnregisterConnectorResponse,
+];
+var UntagResource = [
+    9,
+    n0,
+    _UR,
+    {
+        [_h]: ["DELETE", "/tags/{resourceArn}", 200],
+    },
+    () => UntagResourceRequest,
+    () => UntagResourceResponse,
+];
+var UpdateConnectorProfile = [
+    9,
+    n0,
+    _UCP,
+    {
+        [_h]: ["POST", "/update-connector-profile", 200],
+    },
+    () => UpdateConnectorProfileRequest,
+    () => UpdateConnectorProfileResponse,
+];
+var UpdateConnectorRegistration = [
+    9,
+    n0,
+    _UCRp,
+    {
+        [_h]: ["POST", "/update-connector-registration", 200],
+    },
+    () => UpdateConnectorRegistrationRequest,
+    () => UpdateConnectorRegistrationResponse,
+];
+var UpdateFlow = [
+    9,
+    n0,
+    _UF,
+    {
+        [_h]: ["POST", "/update-flow", 200],
+    },
+    () => UpdateFlowRequest,
+    () => UpdateFlowResponse,
+];
 
 class CancelFlowExecutionsCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SandstoneConfigurationServiceLambda", "CancelFlowExecutions", {})
     .n("AppflowClient", "CancelFlowExecutionsCommand")
-    .f(void 0, void 0)
-    .ser(se_CancelFlowExecutionsCommand)
-    .de(de_CancelFlowExecutionsCommand)
+    .sc(CancelFlowExecutions)
     .build() {
 }
 
@@ -2056,16 +2770,11 @@ class CreateConnectorProfileCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SandstoneConfigurationServiceLambda", "CreateConnectorProfile", {})
     .n("AppflowClient", "CreateConnectorProfileCommand")
-    .f(CreateConnectorProfileRequestFilterSensitiveLog, void 0)
-    .ser(se_CreateConnectorProfileCommand)
-    .de(de_CreateConnectorProfileCommand)
+    .sc(CreateConnectorProfile)
     .build() {
 }
 
@@ -2073,16 +2782,11 @@ class CreateFlowCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SandstoneConfigurationServiceLambda", "CreateFlow", {})
     .n("AppflowClient", "CreateFlowCommand")
-    .f(void 0, void 0)
-    .ser(se_CreateFlowCommand)
-    .de(de_CreateFlowCommand)
+    .sc(CreateFlow)
     .build() {
 }
 
@@ -2090,16 +2794,11 @@ class DeleteConnectorProfileCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SandstoneConfigurationServiceLambda", "DeleteConnectorProfile", {})
     .n("AppflowClient", "DeleteConnectorProfileCommand")
-    .f(void 0, void 0)
-    .ser(se_DeleteConnectorProfileCommand)
-    .de(de_DeleteConnectorProfileCommand)
+    .sc(DeleteConnectorProfile)
     .build() {
 }
 
@@ -2107,16 +2806,11 @@ class DeleteFlowCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SandstoneConfigurationServiceLambda", "DeleteFlow", {})
     .n("AppflowClient", "DeleteFlowCommand")
-    .f(void 0, void 0)
-    .ser(se_DeleteFlowCommand)
-    .de(de_DeleteFlowCommand)
+    .sc(DeleteFlow)
     .build() {
 }
 
@@ -2124,16 +2818,11 @@ class DescribeConnectorCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SandstoneConfigurationServiceLambda", "DescribeConnector", {})
     .n("AppflowClient", "DescribeConnectorCommand")
-    .f(void 0, void 0)
-    .ser(se_DescribeConnectorCommand)
-    .de(de_DescribeConnectorCommand)
+    .sc(DescribeConnector)
     .build() {
 }
 
@@ -2141,16 +2830,11 @@ class DescribeConnectorEntityCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SandstoneConfigurationServiceLambda", "DescribeConnectorEntity", {})
     .n("AppflowClient", "DescribeConnectorEntityCommand")
-    .f(void 0, void 0)
-    .ser(se_DescribeConnectorEntityCommand)
-    .de(de_DescribeConnectorEntityCommand)
+    .sc(DescribeConnectorEntity)
     .build() {
 }
 
@@ -2158,16 +2842,11 @@ class DescribeConnectorProfilesCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SandstoneConfigurationServiceLambda", "DescribeConnectorProfiles", {})
     .n("AppflowClient", "DescribeConnectorProfilesCommand")
-    .f(void 0, void 0)
-    .ser(se_DescribeConnectorProfilesCommand)
-    .de(de_DescribeConnectorProfilesCommand)
+    .sc(DescribeConnectorProfiles)
     .build() {
 }
 
@@ -2175,16 +2854,11 @@ class DescribeConnectorsCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SandstoneConfigurationServiceLambda", "DescribeConnectors", {})
     .n("AppflowClient", "DescribeConnectorsCommand")
-    .f(void 0, void 0)
-    .ser(se_DescribeConnectorsCommand)
-    .de(de_DescribeConnectorsCommand)
+    .sc(DescribeConnectors)
     .build() {
 }
 
@@ -2192,16 +2866,11 @@ class DescribeFlowCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SandstoneConfigurationServiceLambda", "DescribeFlow", {})
     .n("AppflowClient", "DescribeFlowCommand")
-    .f(void 0, void 0)
-    .ser(se_DescribeFlowCommand)
-    .de(de_DescribeFlowCommand)
+    .sc(DescribeFlow)
     .build() {
 }
 
@@ -2209,16 +2878,11 @@ class DescribeFlowExecutionRecordsCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SandstoneConfigurationServiceLambda", "DescribeFlowExecutionRecords", {})
     .n("AppflowClient", "DescribeFlowExecutionRecordsCommand")
-    .f(void 0, void 0)
-    .ser(se_DescribeFlowExecutionRecordsCommand)
-    .de(de_DescribeFlowExecutionRecordsCommand)
+    .sc(DescribeFlowExecutionRecords)
     .build() {
 }
 
@@ -2226,16 +2890,11 @@ class ListConnectorEntitiesCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SandstoneConfigurationServiceLambda", "ListConnectorEntities", {})
     .n("AppflowClient", "ListConnectorEntitiesCommand")
-    .f(void 0, void 0)
-    .ser(se_ListConnectorEntitiesCommand)
-    .de(de_ListConnectorEntitiesCommand)
+    .sc(ListConnectorEntities)
     .build() {
 }
 
@@ -2243,16 +2902,11 @@ class ListConnectorsCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SandstoneConfigurationServiceLambda", "ListConnectors", {})
     .n("AppflowClient", "ListConnectorsCommand")
-    .f(void 0, void 0)
-    .ser(se_ListConnectorsCommand)
-    .de(de_ListConnectorsCommand)
+    .sc(ListConnectors)
     .build() {
 }
 
@@ -2260,16 +2914,11 @@ class ListFlowsCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SandstoneConfigurationServiceLambda", "ListFlows", {})
     .n("AppflowClient", "ListFlowsCommand")
-    .f(void 0, void 0)
-    .ser(se_ListFlowsCommand)
-    .de(de_ListFlowsCommand)
+    .sc(ListFlows)
     .build() {
 }
 
@@ -2277,16 +2926,11 @@ class ListTagsForResourceCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SandstoneConfigurationServiceLambda", "ListTagsForResource", {})
     .n("AppflowClient", "ListTagsForResourceCommand")
-    .f(void 0, void 0)
-    .ser(se_ListTagsForResourceCommand)
-    .de(de_ListTagsForResourceCommand)
+    .sc(ListTagsForResource)
     .build() {
 }
 
@@ -2294,16 +2938,11 @@ class RegisterConnectorCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SandstoneConfigurationServiceLambda", "RegisterConnector", {})
     .n("AppflowClient", "RegisterConnectorCommand")
-    .f(void 0, void 0)
-    .ser(se_RegisterConnectorCommand)
-    .de(de_RegisterConnectorCommand)
+    .sc(RegisterConnector)
     .build() {
 }
 
@@ -2311,16 +2950,11 @@ class ResetConnectorMetadataCacheCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SandstoneConfigurationServiceLambda", "ResetConnectorMetadataCache", {})
     .n("AppflowClient", "ResetConnectorMetadataCacheCommand")
-    .f(void 0, void 0)
-    .ser(se_ResetConnectorMetadataCacheCommand)
-    .de(de_ResetConnectorMetadataCacheCommand)
+    .sc(ResetConnectorMetadataCache)
     .build() {
 }
 
@@ -2328,16 +2962,11 @@ class StartFlowCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SandstoneConfigurationServiceLambda", "StartFlow", {})
     .n("AppflowClient", "StartFlowCommand")
-    .f(void 0, void 0)
-    .ser(se_StartFlowCommand)
-    .de(de_StartFlowCommand)
+    .sc(StartFlow)
     .build() {
 }
 
@@ -2345,16 +2974,11 @@ class StopFlowCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SandstoneConfigurationServiceLambda", "StopFlow", {})
     .n("AppflowClient", "StopFlowCommand")
-    .f(void 0, void 0)
-    .ser(se_StopFlowCommand)
-    .de(de_StopFlowCommand)
+    .sc(StopFlow)
     .build() {
 }
 
@@ -2362,16 +2986,11 @@ class TagResourceCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SandstoneConfigurationServiceLambda", "TagResource", {})
     .n("AppflowClient", "TagResourceCommand")
-    .f(void 0, void 0)
-    .ser(se_TagResourceCommand)
-    .de(de_TagResourceCommand)
+    .sc(TagResource)
     .build() {
 }
 
@@ -2379,16 +2998,11 @@ class UnregisterConnectorCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SandstoneConfigurationServiceLambda", "UnregisterConnector", {})
     .n("AppflowClient", "UnregisterConnectorCommand")
-    .f(void 0, void 0)
-    .ser(se_UnregisterConnectorCommand)
-    .de(de_UnregisterConnectorCommand)
+    .sc(UnregisterConnector)
     .build() {
 }
 
@@ -2396,16 +3010,11 @@ class UntagResourceCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SandstoneConfigurationServiceLambda", "UntagResource", {})
     .n("AppflowClient", "UntagResourceCommand")
-    .f(void 0, void 0)
-    .ser(se_UntagResourceCommand)
-    .de(de_UntagResourceCommand)
+    .sc(UntagResource)
     .build() {
 }
 
@@ -2413,16 +3022,11 @@ class UpdateConnectorProfileCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SandstoneConfigurationServiceLambda", "UpdateConnectorProfile", {})
     .n("AppflowClient", "UpdateConnectorProfileCommand")
-    .f(UpdateConnectorProfileRequestFilterSensitiveLog, void 0)
-    .ser(se_UpdateConnectorProfileCommand)
-    .de(de_UpdateConnectorProfileCommand)
+    .sc(UpdateConnectorProfile)
     .build() {
 }
 
@@ -2430,16 +3034,11 @@ class UpdateConnectorRegistrationCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SandstoneConfigurationServiceLambda", "UpdateConnectorRegistration", {})
     .n("AppflowClient", "UpdateConnectorRegistrationCommand")
-    .f(void 0, void 0)
-    .ser(se_UpdateConnectorRegistrationCommand)
-    .de(de_UpdateConnectorRegistrationCommand)
+    .sc(UpdateConnectorRegistration)
     .build() {
 }
 
@@ -2447,16 +3046,11 @@ class UpdateFlowCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SandstoneConfigurationServiceLambda", "UpdateFlow", {})
     .n("AppflowClient", "UpdateFlowCommand")
-    .f(void 0, void 0)
-    .ser(se_UpdateFlowCommand)
-    .de(de_UpdateFlowCommand)
+    .sc(UpdateFlow)
     .build() {
 }
 
@@ -2509,35 +3103,26 @@ Object.defineProperty(exports, "__Client", {
     enumerable: true,
     get: function () { return smithyClient.Client; }
 });
-exports.AccessDeniedException = AccessDeniedException;
+exports.AccessDeniedException = AccessDeniedException$1;
 exports.AggregationType = AggregationType;
 exports.AmplitudeConnectorOperator = AmplitudeConnectorOperator;
-exports.AmplitudeConnectorProfileCredentialsFilterSensitiveLog = AmplitudeConnectorProfileCredentialsFilterSensitiveLog;
-exports.ApiKeyCredentialsFilterSensitiveLog = ApiKeyCredentialsFilterSensitiveLog;
 exports.Appflow = Appflow;
 exports.AppflowClient = AppflowClient;
-exports.AppflowServiceException = AppflowServiceException;
+exports.AppflowServiceException = AppflowServiceException$1;
 exports.AuthenticationType = AuthenticationType;
-exports.BasicAuthCredentialsFilterSensitiveLog = BasicAuthCredentialsFilterSensitiveLog;
 exports.CancelFlowExecutionsCommand = CancelFlowExecutionsCommand;
 exports.CatalogType = CatalogType;
-exports.ConflictException = ConflictException;
+exports.ConflictException = ConflictException$1;
 exports.ConnectionMode = ConnectionMode;
-exports.ConnectorAuthenticationException = ConnectorAuthenticationException;
-exports.ConnectorProfileConfigFilterSensitiveLog = ConnectorProfileConfigFilterSensitiveLog;
-exports.ConnectorProfileCredentialsFilterSensitiveLog = ConnectorProfileCredentialsFilterSensitiveLog;
+exports.ConnectorAuthenticationException = ConnectorAuthenticationException$1;
 exports.ConnectorProvisioningType = ConnectorProvisioningType;
-exports.ConnectorServerException = ConnectorServerException;
+exports.ConnectorServerException = ConnectorServerException$1;
 exports.ConnectorType = ConnectorType;
 exports.CreateConnectorProfileCommand = CreateConnectorProfileCommand;
-exports.CreateConnectorProfileRequestFilterSensitiveLog = CreateConnectorProfileRequestFilterSensitiveLog;
 exports.CreateFlowCommand = CreateFlowCommand;
-exports.CustomAuthCredentialsFilterSensitiveLog = CustomAuthCredentialsFilterSensitiveLog;
-exports.CustomConnectorProfileCredentialsFilterSensitiveLog = CustomConnectorProfileCredentialsFilterSensitiveLog;
 exports.DataPullMode = DataPullMode;
 exports.DataTransferApiType = DataTransferApiType;
 exports.DatadogConnectorOperator = DatadogConnectorOperator;
-exports.DatadogConnectorProfileCredentialsFilterSensitiveLog = DatadogConnectorProfileCredentialsFilterSensitiveLog;
 exports.DeleteConnectorProfileCommand = DeleteConnectorProfileCommand;
 exports.DeleteFlowCommand = DeleteFlowCommand;
 exports.DescribeConnectorCommand = DescribeConnectorCommand;
@@ -2551,73 +3136,55 @@ exports.ExecutionStatus = ExecutionStatus;
 exports.FileType = FileType;
 exports.FlowStatus = FlowStatus;
 exports.GoogleAnalyticsConnectorOperator = GoogleAnalyticsConnectorOperator;
-exports.GoogleAnalyticsConnectorProfileCredentialsFilterSensitiveLog = GoogleAnalyticsConnectorProfileCredentialsFilterSensitiveLog;
-exports.HoneycodeConnectorProfileCredentialsFilterSensitiveLog = HoneycodeConnectorProfileCredentialsFilterSensitiveLog;
 exports.InforNexusConnectorOperator = InforNexusConnectorOperator;
-exports.InforNexusConnectorProfileCredentialsFilterSensitiveLog = InforNexusConnectorProfileCredentialsFilterSensitiveLog;
-exports.InternalServerException = InternalServerException;
+exports.InternalServerException = InternalServerException$1;
 exports.ListConnectorEntitiesCommand = ListConnectorEntitiesCommand;
 exports.ListConnectorsCommand = ListConnectorsCommand;
 exports.ListFlowsCommand = ListFlowsCommand;
 exports.ListTagsForResourceCommand = ListTagsForResourceCommand;
 exports.MarketoConnectorOperator = MarketoConnectorOperator;
-exports.MarketoConnectorProfileCredentialsFilterSensitiveLog = MarketoConnectorProfileCredentialsFilterSensitiveLog;
-exports.OAuth2CredentialsFilterSensitiveLog = OAuth2CredentialsFilterSensitiveLog;
 exports.OAuth2CustomPropType = OAuth2CustomPropType;
 exports.OAuth2GrantType = OAuth2GrantType;
-exports.OAuthCredentialsFilterSensitiveLog = OAuthCredentialsFilterSensitiveLog;
 exports.Operator = Operator;
 exports.OperatorPropertiesKeys = OperatorPropertiesKeys;
 exports.Operators = Operators;
 exports.PardotConnectorOperator = PardotConnectorOperator;
-exports.PardotConnectorProfileCredentialsFilterSensitiveLog = PardotConnectorProfileCredentialsFilterSensitiveLog;
 exports.PathPrefix = PathPrefix;
 exports.PrefixFormat = PrefixFormat;
 exports.PrefixType = PrefixType;
 exports.PrivateConnectionProvisioningFailureCause = PrivateConnectionProvisioningFailureCause;
 exports.PrivateConnectionProvisioningStatus = PrivateConnectionProvisioningStatus;
-exports.RedshiftConnectorProfileCredentialsFilterSensitiveLog = RedshiftConnectorProfileCredentialsFilterSensitiveLog;
 exports.RegisterConnectorCommand = RegisterConnectorCommand;
 exports.ResetConnectorMetadataCacheCommand = ResetConnectorMetadataCacheCommand;
-exports.ResourceNotFoundException = ResourceNotFoundException;
+exports.ResourceNotFoundException = ResourceNotFoundException$1;
 exports.S3ConnectorOperator = S3ConnectorOperator;
 exports.S3InputFileType = S3InputFileType;
 exports.SAPODataConnectorOperator = SAPODataConnectorOperator;
-exports.SAPODataConnectorProfileCredentialsFilterSensitiveLog = SAPODataConnectorProfileCredentialsFilterSensitiveLog;
 exports.SalesforceConnectorOperator = SalesforceConnectorOperator;
-exports.SalesforceConnectorProfileCredentialsFilterSensitiveLog = SalesforceConnectorProfileCredentialsFilterSensitiveLog;
 exports.SalesforceDataTransferApi = SalesforceDataTransferApi;
 exports.ScheduleFrequencyType = ScheduleFrequencyType;
 exports.ServiceNowConnectorOperator = ServiceNowConnectorOperator;
-exports.ServiceNowConnectorProfileCredentialsFilterSensitiveLog = ServiceNowConnectorProfileCredentialsFilterSensitiveLog;
-exports.ServiceQuotaExceededException = ServiceQuotaExceededException;
+exports.ServiceQuotaExceededException = ServiceQuotaExceededException$1;
 exports.SingularConnectorOperator = SingularConnectorOperator;
-exports.SingularConnectorProfileCredentialsFilterSensitiveLog = SingularConnectorProfileCredentialsFilterSensitiveLog;
 exports.SlackConnectorOperator = SlackConnectorOperator;
-exports.SlackConnectorProfileCredentialsFilterSensitiveLog = SlackConnectorProfileCredentialsFilterSensitiveLog;
-exports.SnowflakeConnectorProfileCredentialsFilterSensitiveLog = SnowflakeConnectorProfileCredentialsFilterSensitiveLog;
 exports.StartFlowCommand = StartFlowCommand;
 exports.StopFlowCommand = StopFlowCommand;
 exports.SupportedDataTransferType = SupportedDataTransferType;
 exports.TagResourceCommand = TagResourceCommand;
 exports.TaskType = TaskType;
-exports.ThrottlingException = ThrottlingException;
+exports.ThrottlingException = ThrottlingException$1;
 exports.TrendmicroConnectorOperator = TrendmicroConnectorOperator;
-exports.TrendmicroConnectorProfileCredentialsFilterSensitiveLog = TrendmicroConnectorProfileCredentialsFilterSensitiveLog;
 exports.TriggerType = TriggerType;
 exports.UnregisterConnectorCommand = UnregisterConnectorCommand;
-exports.UnsupportedOperationException = UnsupportedOperationException;
+exports.UnsupportedOperationException = UnsupportedOperationException$1;
 exports.UntagResourceCommand = UntagResourceCommand;
 exports.UpdateConnectorProfileCommand = UpdateConnectorProfileCommand;
-exports.UpdateConnectorProfileRequestFilterSensitiveLog = UpdateConnectorProfileRequestFilterSensitiveLog;
 exports.UpdateConnectorRegistrationCommand = UpdateConnectorRegistrationCommand;
 exports.UpdateFlowCommand = UpdateFlowCommand;
-exports.ValidationException = ValidationException;
+exports.ValidationException = ValidationException$1;
 exports.VeevaConnectorOperator = VeevaConnectorOperator;
-exports.VeevaConnectorProfileCredentialsFilterSensitiveLog = VeevaConnectorProfileCredentialsFilterSensitiveLog;
 exports.WriteOperationType = WriteOperationType;
 exports.ZendeskConnectorOperator = ZendeskConnectorOperator;
-exports.ZendeskConnectorProfileCredentialsFilterSensitiveLog = ZendeskConnectorProfileCredentialsFilterSensitiveLog;
 exports.paginateDescribeConnectorProfiles = paginateDescribeConnectorProfiles;
 exports.paginateDescribeConnectors = paginateDescribeConnectors;
 exports.paginateDescribeFlowExecutionRecords = paginateDescribeFlowExecutionRecords;