@aws-sdk/client-proton 3.303.0 → 3.308.0

package/dist-es/Proton.js

@@ -10,6 +10,8 @@ import { CreateEnvironmentTemplateCommand, } from "./commands/CreateEnvironmentT
 import { CreateEnvironmentTemplateVersionCommand, } from "./commands/CreateEnvironmentTemplateVersionCommand";
 import { CreateRepositoryCommand, } from "./commands/CreateRepositoryCommand";
 import { CreateServiceCommand, } from "./commands/CreateServiceCommand";
+import { CreateServiceInstanceCommand, } from "./commands/CreateServiceInstanceCommand";
+import { CreateServiceSyncConfigCommand, } from "./commands/CreateServiceSyncConfigCommand";
 import { CreateServiceTemplateCommand, } from "./commands/CreateServiceTemplateCommand";
 import { CreateServiceTemplateVersionCommand, } from "./commands/CreateServiceTemplateVersionCommand";
 import { CreateTemplateSyncConfigCommand, } from "./commands/CreateTemplateSyncConfigCommand";
@@ -20,6 +22,7 @@ import { DeleteEnvironmentTemplateCommand, } from "./commands/DeleteEnvironmentT
 import { DeleteEnvironmentTemplateVersionCommand, } from "./commands/DeleteEnvironmentTemplateVersionCommand";
 import { DeleteRepositoryCommand, } from "./commands/DeleteRepositoryCommand";
 import { DeleteServiceCommand, } from "./commands/DeleteServiceCommand";
+import { DeleteServiceSyncConfigCommand, } from "./commands/DeleteServiceSyncConfigCommand";
 import { DeleteServiceTemplateCommand, } from "./commands/DeleteServiceTemplateCommand";
 import { DeleteServiceTemplateVersionCommand, } from "./commands/DeleteServiceTemplateVersionCommand";
 import { DeleteTemplateSyncConfigCommand, } from "./commands/DeleteTemplateSyncConfigCommand";
@@ -34,6 +37,9 @@ import { GetRepositorySyncStatusCommand, } from "./commands/GetRepositorySyncSta
 import { GetResourcesSummaryCommand, } from "./commands/GetResourcesSummaryCommand";
 import { GetServiceCommand } from "./commands/GetServiceCommand";
 import { GetServiceInstanceCommand, } from "./commands/GetServiceInstanceCommand";
+import { GetServiceInstanceSyncStatusCommand, } from "./commands/GetServiceInstanceSyncStatusCommand";
+import { GetServiceSyncBlockerSummaryCommand, } from "./commands/GetServiceSyncBlockerSummaryCommand";
+import { GetServiceSyncConfigCommand, } from "./commands/GetServiceSyncConfigCommand";
 import { GetServiceTemplateCommand, } from "./commands/GetServiceTemplateCommand";
 import { GetServiceTemplateVersionCommand, } from "./commands/GetServiceTemplateVersionCommand";
 import { GetTemplateSyncConfigCommand, } from "./commands/GetTemplateSyncConfigCommand";
@@ -71,6 +77,8 @@ import { UpdateEnvironmentTemplateVersionCommand, } from "./commands/UpdateEnvir
 import { UpdateServiceCommand, } from "./commands/UpdateServiceCommand";
 import { UpdateServiceInstanceCommand, } from "./commands/UpdateServiceInstanceCommand";
 import { UpdateServicePipelineCommand, } from "./commands/UpdateServicePipelineCommand";
+import { UpdateServiceSyncBlockerCommand, } from "./commands/UpdateServiceSyncBlockerCommand";
+import { UpdateServiceSyncConfigCommand, } from "./commands/UpdateServiceSyncConfigCommand";
 import { UpdateServiceTemplateCommand, } from "./commands/UpdateServiceTemplateCommand";
 import { UpdateServiceTemplateVersionCommand, } from "./commands/UpdateServiceTemplateVersionCommand";
 import { UpdateTemplateSyncConfigCommand, } from "./commands/UpdateTemplateSyncConfigCommand";
@@ -244,6 +252,34 @@ export class Proton extends ProtonClient {
             return this.send(command, optionsOrCb);
         }
     }
+    createServiceInstance(args, optionsOrCb, cb) {
+        const command = new CreateServiceInstanceCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
+    createServiceSyncConfig(args, optionsOrCb, cb) {
+        const command = new CreateServiceSyncConfigCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
     createServiceTemplate(args, optionsOrCb, cb) {
         const command = new CreateServiceTemplateCommand(args);
         if (typeof optionsOrCb === "function") {
@@ -384,6 +420,20 @@ export class Proton extends ProtonClient {
             return this.send(command, optionsOrCb);
         }
     }
+    deleteServiceSyncConfig(args, optionsOrCb, cb) {
+        const command = new DeleteServiceSyncConfigCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
     deleteServiceTemplate(args, optionsOrCb, cb) {
         const command = new DeleteServiceTemplateCommand(args);
         if (typeof optionsOrCb === "function") {
@@ -580,6 +630,48 @@ export class Proton extends ProtonClient {
             return this.send(command, optionsOrCb);
         }
     }
+    getServiceInstanceSyncStatus(args, optionsOrCb, cb) {
+        const command = new GetServiceInstanceSyncStatusCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
+    getServiceSyncBlockerSummary(args, optionsOrCb, cb) {
+        const command = new GetServiceSyncBlockerSummaryCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
+    getServiceSyncConfig(args, optionsOrCb, cb) {
+        const command = new GetServiceSyncConfigCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
     getServiceTemplate(args, optionsOrCb, cb) {
         const command = new GetServiceTemplateCommand(args);
         if (typeof optionsOrCb === "function") {
@@ -1098,6 +1190,34 @@ export class Proton extends ProtonClient {
             return this.send(command, optionsOrCb);
         }
     }
+    updateServiceSyncBlocker(args, optionsOrCb, cb) {
+        const command = new UpdateServiceSyncBlockerCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
+    updateServiceSyncConfig(args, optionsOrCb, cb) {
+        const command = new UpdateServiceSyncConfigCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
     updateServiceTemplate(args, optionsOrCb, cb) {
         const command = new UpdateServiceTemplateCommand(args);
         if (typeof optionsOrCb === "function") {

package/dist-es/commands/CreateServiceInstanceCommand.js

@@ -0,0 +1,42 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { CreateServiceInstanceInputFilterSensitiveLog, CreateServiceInstanceOutputFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_json1_0CreateServiceInstanceCommand, serializeAws_json1_0CreateServiceInstanceCommand, } from "../protocols/Aws_json1_0";
+export class CreateServiceInstanceCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, CreateServiceInstanceCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "ProtonClient";
+        const commandName = "CreateServiceInstanceCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: CreateServiceInstanceInputFilterSensitiveLog,
+            outputFilterSensitiveLog: CreateServiceInstanceOutputFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_json1_0CreateServiceInstanceCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_json1_0CreateServiceInstanceCommand(output, context);
+    }
+}

package/dist-es/commands/CreateServiceSyncConfigCommand.js

@@ -0,0 +1,41 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { deserializeAws_json1_0CreateServiceSyncConfigCommand, serializeAws_json1_0CreateServiceSyncConfigCommand, } from "../protocols/Aws_json1_0";
+export class CreateServiceSyncConfigCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, CreateServiceSyncConfigCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "ProtonClient";
+        const commandName = "CreateServiceSyncConfigCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_json1_0CreateServiceSyncConfigCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_json1_0CreateServiceSyncConfigCommand(output, context);
+    }
+}

package/dist-es/commands/DeleteServiceSyncConfigCommand.js

@@ -0,0 +1,41 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { deserializeAws_json1_0DeleteServiceSyncConfigCommand, serializeAws_json1_0DeleteServiceSyncConfigCommand, } from "../protocols/Aws_json1_0";
+export class DeleteServiceSyncConfigCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, DeleteServiceSyncConfigCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "ProtonClient";
+        const commandName = "DeleteServiceSyncConfigCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_json1_0DeleteServiceSyncConfigCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_json1_0DeleteServiceSyncConfigCommand(output, context);
+    }
+}

package/dist-es/commands/GetServiceInstanceSyncStatusCommand.js

@@ -0,0 +1,41 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { deserializeAws_json1_0GetServiceInstanceSyncStatusCommand, serializeAws_json1_0GetServiceInstanceSyncStatusCommand, } from "../protocols/Aws_json1_0";
+export class GetServiceInstanceSyncStatusCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, GetServiceInstanceSyncStatusCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "ProtonClient";
+        const commandName = "GetServiceInstanceSyncStatusCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_json1_0GetServiceInstanceSyncStatusCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_json1_0GetServiceInstanceSyncStatusCommand(output, context);
+    }
+}

package/dist-es/commands/GetServiceSyncBlockerSummaryCommand.js

@@ -0,0 +1,41 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { deserializeAws_json1_0GetServiceSyncBlockerSummaryCommand, serializeAws_json1_0GetServiceSyncBlockerSummaryCommand, } from "../protocols/Aws_json1_0";
+export class GetServiceSyncBlockerSummaryCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, GetServiceSyncBlockerSummaryCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "ProtonClient";
+        const commandName = "GetServiceSyncBlockerSummaryCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_json1_0GetServiceSyncBlockerSummaryCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_json1_0GetServiceSyncBlockerSummaryCommand(output, context);
+    }
+}

package/dist-es/commands/GetServiceSyncConfigCommand.js

@@ -0,0 +1,41 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { deserializeAws_json1_0GetServiceSyncConfigCommand, serializeAws_json1_0GetServiceSyncConfigCommand, } from "../protocols/Aws_json1_0";
+export class GetServiceSyncConfigCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, GetServiceSyncConfigCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "ProtonClient";
+        const commandName = "GetServiceSyncConfigCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_json1_0GetServiceSyncConfigCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_json1_0GetServiceSyncConfigCommand(output, context);
+    }
+}

package/dist-es/commands/UpdateServiceSyncBlockerCommand.js

@@ -0,0 +1,41 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { deserializeAws_json1_0UpdateServiceSyncBlockerCommand, serializeAws_json1_0UpdateServiceSyncBlockerCommand, } from "../protocols/Aws_json1_0";
+export class UpdateServiceSyncBlockerCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, UpdateServiceSyncBlockerCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "ProtonClient";
+        const commandName = "UpdateServiceSyncBlockerCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_json1_0UpdateServiceSyncBlockerCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_json1_0UpdateServiceSyncBlockerCommand(output, context);
+    }
+}

package/dist-es/commands/UpdateServiceSyncConfigCommand.js

@@ -0,0 +1,41 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { deserializeAws_json1_0UpdateServiceSyncConfigCommand, serializeAws_json1_0UpdateServiceSyncConfigCommand, } from "../protocols/Aws_json1_0";
+export class UpdateServiceSyncConfigCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, UpdateServiceSyncConfigCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "ProtonClient";
+        const commandName = "UpdateServiceSyncConfigCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_json1_0UpdateServiceSyncConfigCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_json1_0UpdateServiceSyncConfigCommand(output, context);
+    }
+}

package/dist-es/commands/index.js

@@ -10,6 +10,8 @@ export * from "./CreateEnvironmentTemplateCommand";
 export * from "./CreateEnvironmentTemplateVersionCommand";
 export * from "./CreateRepositoryCommand";
 export * from "./CreateServiceCommand";
+export * from "./CreateServiceInstanceCommand";
+export * from "./CreateServiceSyncConfigCommand";
 export * from "./CreateServiceTemplateCommand";
 export * from "./CreateServiceTemplateVersionCommand";
 export * from "./CreateTemplateSyncConfigCommand";
@@ -20,6 +22,7 @@ export * from "./DeleteEnvironmentTemplateCommand";
 export * from "./DeleteEnvironmentTemplateVersionCommand";
 export * from "./DeleteRepositoryCommand";
 export * from "./DeleteServiceCommand";
+export * from "./DeleteServiceSyncConfigCommand";
 export * from "./DeleteServiceTemplateCommand";
 export * from "./DeleteServiceTemplateVersionCommand";
 export * from "./DeleteTemplateSyncConfigCommand";
@@ -34,6 +37,9 @@ export * from "./GetRepositorySyncStatusCommand";
 export * from "./GetResourcesSummaryCommand";
 export * from "./GetServiceCommand";
 export * from "./GetServiceInstanceCommand";
+export * from "./GetServiceInstanceSyncStatusCommand";
+export * from "./GetServiceSyncBlockerSummaryCommand";
+export * from "./GetServiceSyncConfigCommand";
 export * from "./GetServiceTemplateCommand";
 export * from "./GetServiceTemplateVersionCommand";
 export * from "./GetTemplateSyncConfigCommand";
@@ -71,6 +77,8 @@ export * from "./UpdateEnvironmentTemplateVersionCommand";
 export * from "./UpdateServiceCommand";
 export * from "./UpdateServiceInstanceCommand";
 export * from "./UpdateServicePipelineCommand";
+export * from "./UpdateServiceSyncBlockerCommand";
+export * from "./UpdateServiceSyncConfigCommand";
 export * from "./UpdateServiceTemplateCommand";
 export * from "./UpdateServiceTemplateVersionCommand";
 export * from "./UpdateTemplateSyncConfigCommand";

package/dist-es/endpoint/ruleset.js

@@ -1,4 +1,4 @@
-const q = "fn", r = "argv", s = "ref";
-const a = true, b = false, c = "String", d = "PartitionResult", e = "tree", f = "error", g = "endpoint", h = { "required": true, "default": false, "type": "Boolean" }, i = { [s]: "Endpoint" }, j = { [q]: "booleanEquals", [r]: [{ [s]: "UseFIPS" }, true] }, k = { [q]: "booleanEquals", [r]: [{ [s]: "UseDualStack" }, true] }, l = {}, m = { [q]: "booleanEquals", [r]: [true, { [q]: "getAttr", [r]: [{ [s]: d }, "supportsFIPS"] }] }, n = { [q]: "booleanEquals", [r]: [true, { [q]: "getAttr", [r]: [{ [s]: d }, "supportsDualStack"] }] }, o = [j], p = [k];
-const _data = { version: "1.0", parameters: { Region: { required: a, type: c }, UseDualStack: h, UseFIPS: h, Endpoint: { required: b, type: c } }, rules: [{ conditions: [{ [q]: "aws.partition", [r]: [{ [s]: "Region" }], assign: d }], type: e, rules: [{ conditions: [{ [q]: "isSet", [r]: [i] }], type: e, rules: [{ conditions: o, error: "Invalid Configuration: FIPS and custom endpoint are not supported", type: f }, { type: e, rules: [{ conditions: p, error: "Invalid Configuration: Dualstack and custom endpoint are not supported", type: f }, { endpoint: { url: i, properties: l, headers: l }, type: g }] }] }, { conditions: [j, k], type: e, rules: [{ conditions: [m, n], type: e, rules: [{ type: e, rules: [{ endpoint: { url: "https://proton-fips.{Region}.{PartitionResult#dualStackDnsSuffix}", properties: l, headers: l }, type: g }] }] }, { error: "FIPS and DualStack are enabled, but this partition does not support one or both", type: f }] }, { conditions: o, type: e, rules: [{ conditions: [m], type: e, rules: [{ type: e, rules: [{ endpoint: { url: "https://proton-fips.{Region}.{PartitionResult#dnsSuffix}", properties: l, headers: l }, type: g }] }] }, { error: "FIPS is enabled but this partition does not support FIPS", type: f }] }, { conditions: p, type: e, rules: [{ conditions: [n], type: e, rules: [{ type: e, rules: [{ endpoint: { url: "https://proton.{Region}.{PartitionResult#dualStackDnsSuffix}", properties: l, headers: l }, type: g }] }] }, { error: "DualStack is enabled but this partition does not support DualStack", type: f }] }, { type: e, rules: [{ endpoint: { url: "https://proton.{Region}.{PartitionResult#dnsSuffix}", properties: l, headers: l }, type: g }] }] }] };
+const q = "required", r = "fn", s = "argv", t = "ref";
+const a = "isSet", b = "tree", c = "error", d = "endpoint", e = "PartitionResult", f = { [q]: false, "type": "String" }, g = { [q]: true, "default": false, "type": "Boolean" }, h = { [t]: "Endpoint" }, i = { [r]: "booleanEquals", [s]: [{ [t]: "UseFIPS" }, true] }, j = { [r]: "booleanEquals", [s]: [{ [t]: "UseDualStack" }, true] }, k = {}, l = { [r]: "booleanEquals", [s]: [true, { [r]: "getAttr", [s]: [{ [t]: e }, "supportsFIPS"] }] }, m = { [r]: "booleanEquals", [s]: [true, { [r]: "getAttr", [s]: [{ [t]: e }, "supportsDualStack"] }] }, n = [i], o = [j], p = [{ [t]: "Region" }];
+const _data = { version: "1.0", parameters: { Region: f, UseDualStack: g, UseFIPS: g, Endpoint: f }, rules: [{ conditions: [{ [r]: a, [s]: [h] }], type: b, rules: [{ conditions: n, error: "Invalid Configuration: FIPS and custom endpoint are not supported", type: c }, { type: b, rules: [{ conditions: o, error: "Invalid Configuration: Dualstack and custom endpoint are not supported", type: c }, { endpoint: { url: h, properties: k, headers: k }, type: d }] }] }, { type: b, rules: [{ conditions: [{ [r]: a, [s]: p }], type: b, rules: [{ conditions: [{ [r]: "aws.partition", [s]: p, assign: e }], type: b, rules: [{ conditions: [i, j], type: b, rules: [{ conditions: [l, m], type: b, rules: [{ type: b, rules: [{ endpoint: { url: "https://proton-fips.{Region}.{PartitionResult#dualStackDnsSuffix}", properties: k, headers: k }, type: d }] }] }, { error: "FIPS and DualStack are enabled, but this partition does not support one or both", type: c }] }, { conditions: n, type: b, rules: [{ conditions: [l], type: b, rules: [{ type: b, rules: [{ endpoint: { url: "https://proton-fips.{Region}.{PartitionResult#dnsSuffix}", properties: k, headers: k }, type: d }] }] }, { error: "FIPS is enabled but this partition does not support FIPS", type: c }] }, { conditions: o, type: b, rules: [{ conditions: [m], type: b, rules: [{ type: b, rules: [{ endpoint: { url: "https://proton.{Region}.{PartitionResult#dualStackDnsSuffix}", properties: k, headers: k }, type: d }] }] }, { error: "DualStack is enabled but this partition does not support DualStack", type: c }] }, { type: b, rules: [{ endpoint: { url: "https://proton.{Region}.{PartitionResult#dnsSuffix}", properties: k, headers: k }, type: d }] }] }] }, { error: "Invalid Configuration: Missing Region", type: c }] }] };
 export const ruleSet = _data;

package/dist-es/models/models_0.js

@@ -144,6 +144,7 @@ export const TemplateVersionStatus = {
     REGISTRATION_IN_PROGRESS: "REGISTRATION_IN_PROGRESS",
 };
 export const SyncType = {
+    SERVICE_SYNC: "SERVICE_SYNC",
     TEMPLATE_SYNC: "TEMPLATE_SYNC",
 };
 export const RepositorySyncStatus = {
@@ -153,16 +154,16 @@ export const RepositorySyncStatus = {
     QUEUED: "QUEUED",
     SUCCEEDED: "SUCCEEDED",
 };
-export const TemplateType = {
-    ENVIRONMENT: "ENVIRONMENT",
-    SERVICE: "SERVICE",
-};
 export const ResourceSyncStatus = {
     FAILED: "FAILED",
     INITIATED: "INITIATED",
     IN_PROGRESS: "IN_PROGRESS",
     SUCCEEDED: "SUCCEEDED",
 };
+export const TemplateType = {
+    ENVIRONMENT: "ENVIRONMENT",
+    SERVICE: "SERVICE",
+};
 export const ResourceDeploymentStatus = {
     FAILED: "FAILED",
     IN_PROGRESS: "IN_PROGRESS",
@@ -209,6 +210,13 @@ export const ServiceStatus = {
     UPDATE_FAILED_CLEANUP_IN_PROGRESS: "UPDATE_FAILED_CLEANUP_IN_PROGRESS",
     UPDATE_IN_PROGRESS: "UPDATE_IN_PROGRESS",
 };
+export const BlockerStatus = {
+    ACTIVE: "ACTIVE",
+    RESOLVED: "RESOLVED",
+};
+export const BlockerType = {
+    AUTOMATED: "AUTOMATED",
+};
 export const ServiceTemplateSupportedComponentSourceType = {
     DIRECTLY_DEFINED: "DIRECTLY_DEFINED",
 };
@@ -440,6 +448,14 @@ export const ListServiceInstanceOutputsOutputFilterSensitiveLog = (obj) => ({
     ...obj,
     ...(obj.outputs && { outputs: SENSITIVE_STRING }),
 });
+export const CreateServiceInstanceInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.spec && { spec: SENSITIVE_STRING }),
+});
+export const CreateServiceInstanceOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.serviceInstance && { serviceInstance: ServiceInstanceFilterSensitiveLog(obj.serviceInstance) }),
+});
 export const GetServiceInstanceOutputFilterSensitiveLog = (obj) => ({
     ...obj,
     ...(obj.serviceInstance && { serviceInstance: ServiceInstanceFilterSensitiveLog(obj.serviceInstance) }),