/*******************************************************************************
* Copyright 2012-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
* Licensed under the Apache License, Version 2.0 (the "License"). You may not use
* this file except in compliance with the License. A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file.
* This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied. See the License for the
* specific language governing permissions and limitations under the License.
* *****************************************************************************
*
* AWS Tools for Windows (TM) PowerShell (TM)
*
*/
using System;
using System.Collections.Generic;
using System.Linq;
using System.Management.Automation;
using System.Text;
using Amazon.PowerShell.Common;
using Amazon.Runtime;
using Amazon.LexRuntimeV2;
using Amazon.LexRuntimeV2.Model;
namespace Amazon.PowerShell.Cmdlets.LRSV2
{
/// <summary>
/// Creates a new session or modifies an existing session with an Amazon Lex V2 bot. Use
/// this operation to enable your application to set the state of the bot.
/// </summary>
[Cmdlet("Write", "LRSV2Session", SupportsShouldProcess = true, ConfirmImpact = ConfirmImpact.Medium)]
[OutputType("Amazon.LexRuntimeV2.Model.PutSessionResponse")]
[AWSCmdlet("Calls the Amazon Lex Runtime V2 PutSession API operation.", Operation = new[] {"PutSession"}, SelectReturnType = typeof(Amazon.LexRuntimeV2.Model.PutSessionResponse))]
[AWSCmdletOutput("Amazon.LexRuntimeV2.Model.PutSessionResponse",
"This cmdlet returns an Amazon.LexRuntimeV2.Model.PutSessionResponse object containing multiple properties. The object can also be referenced from properties attached to the cmdlet entry in the $AWSHistory stack."
)]
public partial class WriteLRSV2SessionCmdlet : AmazonLexRuntimeV2ClientCmdlet, IExecutor
{
protected override bool IsSensitiveRequest { get; set; } = true;
#region Parameter SessionStateValue_ActiveContext
/// <summary>
/// <para>
/// <para>One or more contexts that indicate to Amazon Lex V2 the context of a request. When
/// a context is active, Amazon Lex V2 considers intents with the matching context as
/// a trigger as the next intent in a session.</para>
/// </para>
/// </summary>
[System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)]
[Alias("SessionStateValue_ActiveContexts")]
public Amazon.LexRuntimeV2.Model.ActiveContext[] SessionStateValue_ActiveContext { get; set; }
#endregion
#region Parameter BotAliasId
/// <summary>
/// <para>
/// <para>The alias identifier of the bot that receives the session data.</para>
/// </para>
/// </summary>
#if !MODULAR
[System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)]
#else
[System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true, Mandatory = true)]
[System.Management.Automation.AllowEmptyString]
[System.Management.Automation.AllowNull]
#endif
[Amazon.PowerShell.Common.AWSRequiredParameter]
public System.String BotAliasId { get; set; }
#endregion
#region Parameter BotId
/// <summary>
/// <para>
/// <para>The identifier of the bot that receives the session data.</para>
/// </para>
/// </summary>
#if !MODULAR
[System.Management.Automation.Parameter(Position = 0, ValueFromPipelineByPropertyName = true, ValueFromPipeline = true)]
#else
[System.Management.Automation.Parameter(Position = 0, ValueFromPipelineByPropertyName = true, ValueFromPipeline = true, Mandatory = true)]
[System.Management.Automation.AllowEmptyString]
[System.Management.Automation.AllowNull]
#endif
[Amazon.PowerShell.Common.AWSRequiredParameter]
public System.String BotId { get; set; }
#endregion
#region Parameter Intent_ConfirmationState
/// <summary>
/// <para>
/// <para>Contains information about whether fulfillment of the intent has been confirmed.</para>
/// </para>
/// </summary>
[System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)]
[Alias("SessionStateValue_Intent_ConfirmationState")]
[AWSConstantClassSource("Amazon.LexRuntimeV2.ConfirmationState")]
public Amazon.LexRuntimeV2.ConfirmationState Intent_ConfirmationState { get; set; }
#endregion
#region Parameter LocaleId
/// <summary>
/// <para>
/// <para>The locale where the session is in use.</para>
/// </para>
/// </summary>
#if !MODULAR
[System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)]
#else
[System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true, Mandatory = true)]
[System.Management.Automation.AllowEmptyString]
[System.Management.Automation.AllowNull]
#endif
[Amazon.PowerShell.Common.AWSRequiredParameter]
public System.String LocaleId { get; set; }
#endregion
#region Parameter Message
/// <summary>
/// <para>
/// <para>A list of messages to send to the user. Messages are sent in the order that they are
/// defined in the list.</para>
/// </para>
/// </summary>
[System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)]
[Alias("Messages")]
public Amazon.LexRuntimeV2.Model.Message[] Message { get; set; }
#endregion
#region Parameter Intent_Name
/// <summary>
/// <para>
/// <para>The name of the intent.</para>
/// </para>
/// </summary>
[System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)]
[Alias("SessionStateValue_Intent_Name")]
public System.String Intent_Name { get; set; }
#endregion
#region Parameter SessionStateValue_OriginatingRequestId
/// <summary>
/// <para>
/// <para>A unique identifier for a specific request.</para>
/// </para>
/// </summary>
[System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)]
public System.String SessionStateValue_OriginatingRequestId { get; set; }
#endregion
#region Parameter RequestAttribute
/// <summary>
/// <para>
/// <para>Request-specific information passed between Amazon Lex V2 and the client application.</para><para>The namespace <code>x-amz-lex:</code> is reserved for special attributes. Don't create
/// any request attributes with the prefix <code>x-amz-lex:</code>.</para>
/// </para>
/// </summary>
[System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)]
[Alias("RequestAttributes")]
public System.Collections.Hashtable RequestAttribute { get; set; }
#endregion
#region Parameter ResponseContentType
/// <summary>
/// <para>
/// <para>The message that Amazon Lex V2 returns in the response can be either text or speech
/// depending on the value of this parameter. </para><ul><li><para>If the value is <code>text/plain; charset=utf-8</code>, Amazon Lex V2 returns text
/// in the response.</para></li></ul>
/// </para>
/// </summary>
[System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)]
public System.String ResponseContentType { get; set; }
#endregion
#region Parameter SessionStateValue_SessionAttribute
/// <summary>
/// <para>
/// <para>Map of key/value pairs representing session-specific context information. It contains
/// application information passed between Amazon Lex V2 and a client application.</para>
/// </para>
/// </summary>
[System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)]
[Alias("SessionStateValue_SessionAttributes")]
public System.Collections.Hashtable SessionStateValue_SessionAttribute { get; set; }
#endregion
#region Parameter SessionId
/// <summary>
/// <para>
/// <para>The identifier of the session that receives the session data.</para>
/// </para>
/// </summary>
#if !MODULAR
[System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)]
#else
[System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true, Mandatory = true)]
[System.Management.Automation.AllowEmptyString]
[System.Management.Automation.AllowNull]
#endif
[Amazon.PowerShell.Common.AWSRequiredParameter]
public System.String SessionId { get; set; }
#endregion
#region Parameter DialogAction_SlotElicitationStyle
/// <summary>
/// <para>
/// <para>Configures the slot to use spell-by-letter or spell-by-word style. When you use a
/// style on a slot, users can spell out their input to make it clear to your bot.</para><ul><li><para>Spell by letter - "b" "o" "b"</para></li><li><para>Spell by word - "b as in boy" "o as in oscar" "b as in boy"</para></li></ul><para>For more information, see <a href="https://docs.aws.amazon.com/lexv2/latest/dg/using-spelling.html">
/// Using spelling to enter slot values </a>.</para>
/// </para>
/// </summary>
[System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)]
[Alias("SessionStateValue_DialogAction_SlotElicitationStyle")]
[AWSConstantClassSource("Amazon.LexRuntimeV2.StyleType")]
public Amazon.LexRuntimeV2.StyleType DialogAction_SlotElicitationStyle { get; set; }
#endregion
#region Parameter RuntimeHints_SlotHint
/// <summary>
/// <para>
/// <para>A list of the slots in the intent that should have runtime hints added, and the phrases
/// that should be added for each slot.</para><para>The first level of the <code>slotHints</code> map is the name of the intent. The second
/// level is the name of the slot within the intent. For more information, see <a href="https://docs.aws.amazon.com/lexv2/latest/dg/using-hints.html">Using
/// hints to improve accuracy</a>.</para><para>The intent name and slot name must exist.</para>
/// </para>
/// </summary>
[System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)]
[Alias("SessionStateValue_RuntimeHints_SlotHints")]
public System.Collections.Hashtable RuntimeHints_SlotHint { get; set; }
#endregion
#region Parameter Intent_Slot
/// <summary>
/// <para>
/// <para>A map of all of the slots for the intent. The name of the slot maps to the value of
/// the slot. If a slot has not been filled, the value is null.</para>
/// </para>
/// </summary>
[System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)]
[Alias("SessionStateValue_Intent_Slots")]
public System.Collections.Hashtable Intent_Slot { get; set; }
#endregion
#region Parameter DialogAction_SlotToElicit
/// <summary>
/// <para>
/// <para>The name of the slot that should be elicited from the user.</para>
/// </para>
/// </summary>
[System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)]
[Alias("SessionStateValue_DialogAction_SlotToElicit")]
public System.String DialogAction_SlotToElicit { get; set; }
#endregion
#region Parameter Intent_State
/// <summary>
/// <para>
/// <para>Contains fulfillment information for the intent. </para>
/// </para>
/// </summary>
[System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)]
[Alias("SessionStateValue_Intent_State")]
[AWSConstantClassSource("Amazon.LexRuntimeV2.IntentState")]
public Amazon.LexRuntimeV2.IntentState Intent_State { get; set; }
#endregion
#region Parameter DialogAction_SubSlotToElicit
/// <summary>
/// <para>
/// <para>The name of the constituent sub slot of the composite slot specified in slotToElicit
/// that should be elicited from the user.</para>
/// </para>
/// </summary>
[System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)]
[Alias("SessionStateValue_DialogAction_SubSlotToElicit")]
public Amazon.LexRuntimeV2.Model.ElicitSubSlot DialogAction_SubSlotToElicit { get; set; }
#endregion
#region Parameter DialogAction_Type
/// <summary>
/// <para>
/// <para>The next action that the bot should take in its interaction with the user. The possible
/// values are:</para><ul><li><para><code>Close</code> - Indicates that there will not be a response from the user. For
/// example, the statement "Your order has been placed" does not require a response.</para></li><li><para><code>ConfirmIntent</code> - The next action is asking the user if the intent is
/// complete and ready to be fulfilled. This is a yes/no question such as "Place the order?"</para></li><li><para><code>Delegate</code> - The next action is determined by Amazon Lex V2.</para></li><li><para><code>ElicitIntent</code> - The next action is to elicit an intent from the user.</para></li><li><para><code>ElicitSlot</code> - The next action is to elicit a slot value from the user.</para></li></ul>
/// </para>
/// </summary>
[System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)]
[Alias("SessionStateValue_DialogAction_Type")]
[AWSConstantClassSource("Amazon.LexRuntimeV2.DialogActionType")]
public Amazon.LexRuntimeV2.DialogActionType DialogAction_Type { get; set; }
#endregion
#region Parameter Select
/// <summary>
/// Use the -Select parameter to control the cmdlet output. The default value is '*'.
/// Specifying -Select '*' will result in the cmdlet returning the whole service response (Amazon.LexRuntimeV2.Model.PutSessionResponse).
/// Specifying the name of a property of type Amazon.LexRuntimeV2.Model.PutSessionResponse will result in that property being returned.
/// Specifying -Select '^ParameterName' will result in the cmdlet returning the selected cmdlet parameter value.
/// </summary>
[System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)]
public string Select { get; set; } = "*";
#endregion
#region Parameter PassThru
/// <summary>
/// Changes the cmdlet behavior to return the value passed to the BotId parameter.
/// The -PassThru parameter is deprecated, use -Select '^BotId' instead. This parameter will be removed in a future version.
/// </summary>
[System.Obsolete("The -PassThru parameter is deprecated, use -Select '^BotId' instead. This parameter will be removed in a future version.")]
[System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)]
public SwitchParameter PassThru { get; set; }
#endregion
#region Parameter Force
/// <summary>
/// This parameter overrides confirmation prompts to force
/// the cmdlet to continue its operation. This parameter should always
/// be used with caution.
/// </summary>
[System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)]
public SwitchParameter Force { get; set; }
#endregion
protected override void ProcessRecord()
{
this._AWSSignerType = "v4";
base.ProcessRecord();
var resourceIdentifiersText = FormatParameterValuesForConfirmationMsg(nameof(this.BotId), MyInvocation.BoundParameters);
if (!ConfirmShouldProceed(this.Force.IsPresent, resourceIdentifiersText, "Write-LRSV2Session (PutSession)"))
{
return;
}
var context = new CmdletContext();
// allow for manipulation of parameters prior to loading into context
PreExecutionContextLoad(context);
#pragma warning disable CS0618, CS0612 //A class member was marked with the Obsolete attribute
if (ParameterWasBound(nameof(this.Select)))
{
context.Select = CreateSelectDelegate<Amazon.LexRuntimeV2.Model.PutSessionResponse, WriteLRSV2SessionCmdlet>(Select) ??
throw new System.ArgumentException("Invalid value for -Select parameter.", nameof(this.Select));
if (this.PassThru.IsPresent)
{
throw new System.ArgumentException("-PassThru cannot be used when -Select is specified.", nameof(this.Select));
}
}
else if (this.PassThru.IsPresent)
{
context.Select = (response, cmdlet) => this.BotId;
}
#pragma warning restore CS0618, CS0612 //A class member was marked with the Obsolete attribute
context.BotAliasId = this.BotAliasId;
#if MODULAR
if (this.BotAliasId == null && ParameterWasBound(nameof(this.BotAliasId)))
{
WriteWarning("You are passing $null as a value for parameter BotAliasId which is marked as required. In case you believe this parameter was incorrectly marked as required, report this by opening an issue at https://github.com/aws/aws-tools-for-powershell/issues.");
}
#endif
context.BotId = this.BotId;
#if MODULAR
if (this.BotId == null && ParameterWasBound(nameof(this.BotId)))
{
WriteWarning("You are passing $null as a value for parameter BotId which is marked as required. In case you believe this parameter was incorrectly marked as required, report this by opening an issue at https://github.com/aws/aws-tools-for-powershell/issues.");
}
#endif
context.LocaleId = this.LocaleId;
#if MODULAR
if (this.LocaleId == null && ParameterWasBound(nameof(this.LocaleId)))
{
WriteWarning("You are passing $null as a value for parameter LocaleId which is marked as required. In case you believe this parameter was incorrectly marked as required, report this by opening an issue at https://github.com/aws/aws-tools-for-powershell/issues.");
}
#endif
if (this.Message != null)
{
context.Message = new List<Amazon.LexRuntimeV2.Model.Message>(this.Message);
}
if (this.RequestAttribute != null)
{
context.RequestAttribute = new Dictionary<System.String, System.String>(StringComparer.Ordinal);
foreach (var hashKey in this.RequestAttribute.Keys)
{
context.RequestAttribute.Add((String)hashKey, (String)(this.RequestAttribute[hashKey]));
}
}
context.ResponseContentType = this.ResponseContentType;
context.SessionId = this.SessionId;
#if MODULAR
if (this.SessionId == null && ParameterWasBound(nameof(this.SessionId)))
{
WriteWarning("You are passing $null as a value for parameter SessionId which is marked as required. In case you believe this parameter was incorrectly marked as required, report this by opening an issue at https://github.com/aws/aws-tools-for-powershell/issues.");
}
#endif
if (this.SessionStateValue_ActiveContext != null)
{
context.SessionStateValue_ActiveContext = new List<Amazon.LexRuntimeV2.Model.ActiveContext>(this.SessionStateValue_ActiveContext);
}
context.DialogAction_SlotElicitationStyle = this.DialogAction_SlotElicitationStyle;
context.DialogAction_SlotToElicit = this.DialogAction_SlotToElicit;
context.DialogAction_SubSlotToElicit = this.DialogAction_SubSlotToElicit;
context.DialogAction_Type = this.DialogAction_Type;
context.Intent_ConfirmationState = this.Intent_ConfirmationState;
context.Intent_Name = this.Intent_Name;
if (this.Intent_Slot != null)
{
context.Intent_Slot = new Dictionary<System.String, Amazon.LexRuntimeV2.Model.Slot>(StringComparer.Ordinal);
foreach (var hashKey in this.Intent_Slot.Keys)
{
context.Intent_Slot.Add((String)hashKey, (Slot)(this.Intent_Slot[hashKey]));
}
}
context.Intent_State = this.Intent_State;
context.SessionStateValue_OriginatingRequestId = this.SessionStateValue_OriginatingRequestId;
if (this.RuntimeHints_SlotHint != null)
{
context.RuntimeHints_SlotHint = new Dictionary<System.String, Dictionary<System.String, Amazon.LexRuntimeV2.Model.RuntimeHintDetails>>(StringComparer.Ordinal);
foreach (var hashKey in this.RuntimeHints_SlotHint.Keys)
{
context.RuntimeHints_SlotHint.Add((String)hashKey, (Dictionary<String,RuntimeHintDetails>)(this.RuntimeHints_SlotHint[hashKey]));
}
}
if (this.SessionStateValue_SessionAttribute != null)
{
context.SessionStateValue_SessionAttribute = new Dictionary<System.String, System.String>(StringComparer.Ordinal);
foreach (var hashKey in this.SessionStateValue_SessionAttribute.Keys)
{
context.SessionStateValue_SessionAttribute.Add((String)hashKey, (String)(this.SessionStateValue_SessionAttribute[hashKey]));
}
}
// allow further manipulation of loaded context prior to processing
PostExecutionContextLoad(context);
var output = Execute(context) as CmdletOutput;
ProcessOutput(output);
}
#region IExecutor Members
public object Execute(ExecutorContext context)
{
var cmdletContext = context as CmdletContext;
// create request
var request = new Amazon.LexRuntimeV2.Model.PutSessionRequest();
if (cmdletContext.BotAliasId != null)
{
request.BotAliasId = cmdletContext.BotAliasId;
}
if (cmdletContext.BotId != null)
{
request.BotId = cmdletContext.BotId;
}
if (cmdletContext.LocaleId != null)
{
request.LocaleId = cmdletContext.LocaleId;
}
if (cmdletContext.Message != null)
{
request.Messages = cmdletContext.Message;
}
if (cmdletContext.RequestAttribute != null)
{
request.RequestAttributes = cmdletContext.RequestAttribute;
}
if (cmdletContext.ResponseContentType != null)
{
request.ResponseContentType = cmdletContext.ResponseContentType;
}
if (cmdletContext.SessionId != null)
{
request.SessionId = cmdletContext.SessionId;
}
// populate SessionStateValue
var requestSessionStateValueIsNull = true;
request.SessionStateValue = new Amazon.LexRuntimeV2.Model.SessionState();
List<Amazon.LexRuntimeV2.Model.ActiveContext> requestSessionStateValue_sessionStateValue_ActiveContext = null;
if (cmdletContext.SessionStateValue_ActiveContext != null)
{
requestSessionStateValue_sessionStateValue_ActiveContext = cmdletContext.SessionStateValue_ActiveContext;
}
if (requestSessionStateValue_sessionStateValue_ActiveContext != null)
{
request.SessionStateValue.ActiveContexts = requestSessionStateValue_sessionStateValue_ActiveContext;
requestSessionStateValueIsNull = false;
}
System.String requestSessionStateValue_sessionStateValue_OriginatingRequestId = null;
if (cmdletContext.SessionStateValue_OriginatingRequestId != null)
{
requestSessionStateValue_sessionStateValue_OriginatingRequestId = cmdletContext.SessionStateValue_OriginatingRequestId;
}
if (requestSessionStateValue_sessionStateValue_OriginatingRequestId != null)
{
request.SessionStateValue.OriginatingRequestId = requestSessionStateValue_sessionStateValue_OriginatingRequestId;
requestSessionStateValueIsNull = false;
}
Dictionary<System.String, System.String> requestSessionStateValue_sessionStateValue_SessionAttribute = null;
if (cmdletContext.SessionStateValue_SessionAttribute != null)
{
requestSessionStateValue_sessionStateValue_SessionAttribute = cmdletContext.SessionStateValue_SessionAttribute;
}
if (requestSessionStateValue_sessionStateValue_SessionAttribute != null)
{
request.SessionStateValue.SessionAttributes = requestSessionStateValue_sessionStateValue_SessionAttribute;
requestSessionStateValueIsNull = false;
}
Amazon.LexRuntimeV2.Model.RuntimeHints requestSessionStateValue_sessionStateValue_RuntimeHints = null;
// populate RuntimeHints
var requestSessionStateValue_sessionStateValue_RuntimeHintsIsNull = true;
requestSessionStateValue_sessionStateValue_RuntimeHints = new Amazon.LexRuntimeV2.Model.RuntimeHints();
Dictionary<System.String, Dictionary<System.String, Amazon.LexRuntimeV2.Model.RuntimeHintDetails>> requestSessionStateValue_sessionStateValue_RuntimeHints_runtimeHints_SlotHint = null;
if (cmdletContext.RuntimeHints_SlotHint != null)
{
requestSessionStateValue_sessionStateValue_RuntimeHints_runtimeHints_SlotHint = cmdletContext.RuntimeHints_SlotHint;
}
if (requestSessionStateValue_sessionStateValue_RuntimeHints_runtimeHints_SlotHint != null)
{
requestSessionStateValue_sessionStateValue_RuntimeHints.SlotHints = requestSessionStateValue_sessionStateValue_RuntimeHints_runtimeHints_SlotHint;
requestSessionStateValue_sessionStateValue_RuntimeHintsIsNull = false;
}
// determine if requestSessionStateValue_sessionStateValue_RuntimeHints should be set to null
if (requestSessionStateValue_sessionStateValue_RuntimeHintsIsNull)
{
requestSessionStateValue_sessionStateValue_RuntimeHints = null;
}
if (requestSessionStateValue_sessionStateValue_RuntimeHints != null)
{
request.SessionStateValue.RuntimeHints = requestSessionStateValue_sessionStateValue_RuntimeHints;
requestSessionStateValueIsNull = false;
}
Amazon.LexRuntimeV2.Model.DialogAction requestSessionStateValue_sessionStateValue_DialogAction = null;
// populate DialogAction
var requestSessionStateValue_sessionStateValue_DialogActionIsNull = true;
requestSessionStateValue_sessionStateValue_DialogAction = new Amazon.LexRuntimeV2.Model.DialogAction();
Amazon.LexRuntimeV2.StyleType requestSessionStateValue_sessionStateValue_DialogAction_dialogAction_SlotElicitationStyle = null;
if (cmdletContext.DialogAction_SlotElicitationStyle != null)
{
requestSessionStateValue_sessionStateValue_DialogAction_dialogAction_SlotElicitationStyle = cmdletContext.DialogAction_SlotElicitationStyle;
}
if (requestSessionStateValue_sessionStateValue_DialogAction_dialogAction_SlotElicitationStyle != null)
{
requestSessionStateValue_sessionStateValue_DialogAction.SlotElicitationStyle = requestSessionStateValue_sessionStateValue_DialogAction_dialogAction_SlotElicitationStyle;
requestSessionStateValue_sessionStateValue_DialogActionIsNull = false;
}
System.String requestSessionStateValue_sessionStateValue_DialogAction_dialogAction_SlotToElicit = null;
if (cmdletContext.DialogAction_SlotToElicit != null)
{
requestSessionStateValue_sessionStateValue_DialogAction_dialogAction_SlotToElicit = cmdletContext.DialogAction_SlotToElicit;
}
if (requestSessionStateValue_sessionStateValue_DialogAction_dialogAction_SlotToElicit != null)
{
requestSessionStateValue_sessionStateValue_DialogAction.SlotToElicit = requestSessionStateValue_sessionStateValue_DialogAction_dialogAction_SlotToElicit;
requestSessionStateValue_sessionStateValue_DialogActionIsNull = false;
}
Amazon.LexRuntimeV2.Model.ElicitSubSlot requestSessionStateValue_sessionStateValue_DialogAction_dialogAction_SubSlotToElicit = null;
if (cmdletContext.DialogAction_SubSlotToElicit != null)
{
requestSessionStateValue_sessionStateValue_DialogAction_dialogAction_SubSlotToElicit = cmdletContext.DialogAction_SubSlotToElicit;
}
if (requestSessionStateValue_sessionStateValue_DialogAction_dialogAction_SubSlotToElicit != null)
{
requestSessionStateValue_sessionStateValue_DialogAction.SubSlotToElicit = requestSessionStateValue_sessionStateValue_DialogAction_dialogAction_SubSlotToElicit;
requestSessionStateValue_sessionStateValue_DialogActionIsNull = false;
}
Amazon.LexRuntimeV2.DialogActionType requestSessionStateValue_sessionStateValue_DialogAction_dialogAction_Type = null;
if (cmdletContext.DialogAction_Type != null)
{
requestSessionStateValue_sessionStateValue_DialogAction_dialogAction_Type = cmdletContext.DialogAction_Type;
}
if (requestSessionStateValue_sessionStateValue_DialogAction_dialogAction_Type != null)
{
requestSessionStateValue_sessionStateValue_DialogAction.Type = requestSessionStateValue_sessionStateValue_DialogAction_dialogAction_Type;
requestSessionStateValue_sessionStateValue_DialogActionIsNull = false;
}
// determine if requestSessionStateValue_sessionStateValue_DialogAction should be set to null
if (requestSessionStateValue_sessionStateValue_DialogActionIsNull)
{
requestSessionStateValue_sessionStateValue_DialogAction = null;
}
if (requestSessionStateValue_sessionStateValue_DialogAction != null)
{
request.SessionStateValue.DialogAction = requestSessionStateValue_sessionStateValue_DialogAction;
requestSessionStateValueIsNull = false;
}
Amazon.LexRuntimeV2.Model.Intent requestSessionStateValue_sessionStateValue_Intent = null;
// populate Intent
var requestSessionStateValue_sessionStateValue_IntentIsNull = true;
requestSessionStateValue_sessionStateValue_Intent = new Amazon.LexRuntimeV2.Model.Intent();
Amazon.LexRuntimeV2.ConfirmationState requestSessionStateValue_sessionStateValue_Intent_intent_ConfirmationState = null;
if (cmdletContext.Intent_ConfirmationState != null)
{
requestSessionStateValue_sessionStateValue_Intent_intent_ConfirmationState = cmdletContext.Intent_ConfirmationState;
}
if (requestSessionStateValue_sessionStateValue_Intent_intent_ConfirmationState != null)
{
requestSessionStateValue_sessionStateValue_Intent.ConfirmationState = requestSessionStateValue_sessionStateValue_Intent_intent_ConfirmationState;
requestSessionStateValue_sessionStateValue_IntentIsNull = false;
}
System.String requestSessionStateValue_sessionStateValue_Intent_intent_Name = null;
if (cmdletContext.Intent_Name != null)
{
requestSessionStateValue_sessionStateValue_Intent_intent_Name = cmdletContext.Intent_Name;
}
if (requestSessionStateValue_sessionStateValue_Intent_intent_Name != null)
{
requestSessionStateValue_sessionStateValue_Intent.Name = requestSessionStateValue_sessionStateValue_Intent_intent_Name;
requestSessionStateValue_sessionStateValue_IntentIsNull = false;
}
Dictionary<System.String, Amazon.LexRuntimeV2.Model.Slot> requestSessionStateValue_sessionStateValue_Intent_intent_Slot = null;
if (cmdletContext.Intent_Slot != null)
{
requestSessionStateValue_sessionStateValue_Intent_intent_Slot = cmdletContext.Intent_Slot;
}
if (requestSessionStateValue_sessionStateValue_Intent_intent_Slot != null)
{
requestSessionStateValue_sessionStateValue_Intent.Slots = requestSessionStateValue_sessionStateValue_Intent_intent_Slot;
requestSessionStateValue_sessionStateValue_IntentIsNull = false;
}
Amazon.LexRuntimeV2.IntentState requestSessionStateValue_sessionStateValue_Intent_intent_State = null;
if (cmdletContext.Intent_State != null)
{
requestSessionStateValue_sessionStateValue_Intent_intent_State = cmdletContext.Intent_State;
}
if (requestSessionStateValue_sessionStateValue_Intent_intent_State != null)
{
requestSessionStateValue_sessionStateValue_Intent.State = requestSessionStateValue_sessionStateValue_Intent_intent_State;
requestSessionStateValue_sessionStateValue_IntentIsNull = false;
}
// determine if requestSessionStateValue_sessionStateValue_Intent should be set to null
if (requestSessionStateValue_sessionStateValue_IntentIsNull)
{
requestSessionStateValue_sessionStateValue_Intent = null;
}
if (requestSessionStateValue_sessionStateValue_Intent != null)
{
request.SessionStateValue.Intent = requestSessionStateValue_sessionStateValue_Intent;
requestSessionStateValueIsNull = false;
}
// determine if request.SessionStateValue should be set to null
if (requestSessionStateValueIsNull)
{
request.SessionStateValue = null;
}
CmdletOutput output;
// issue call
var client = Client ?? CreateClient(_CurrentCredentials, _RegionEndpoint);
try
{
var response = CallAWSServiceOperation(client, request);
object pipelineOutput = null;
pipelineOutput = cmdletContext.Select(response, this);
output = new CmdletOutput
{
PipelineOutput = pipelineOutput,
ServiceResponse = response
};
}
catch (Exception e)
{
output = new CmdletOutput { ErrorResponse = e };
}
return output;
}
public ExecutorContext CreateContext()
{
return new CmdletContext();
}
#endregion
#region AWS Service Operation Call
private Amazon.LexRuntimeV2.Model.PutSessionResponse CallAWSServiceOperation(IAmazonLexRuntimeV2 client, Amazon.LexRuntimeV2.Model.PutSessionRequest request)
{
Utils.Common.WriteVerboseEndpointMessage(this, client.Config, "Amazon Lex Runtime V2", "PutSession");
try
{
#if DESKTOP
return client.PutSession(request);
#elif CORECLR
return client.PutSessionAsync(request).GetAwaiter().GetResult();
#else
#error "Unknown build edition"
#endif
}
catch (AmazonServiceException exc)
{
var webException = exc.InnerException as System.Net.WebException;
if (webException != null)
{
throw new Exception(Utils.Common.FormatNameResolutionFailureMessage(client.Config, webException.Message), webException);
}
throw;
}
}
#endregion
internal partial class CmdletContext : ExecutorContext
{
public System.String BotAliasId { get; set; }
public System.String BotId { get; set; }
public System.String LocaleId { get; set; }
public List<Amazon.LexRuntimeV2.Model.Message> Message { get; set; }
public Dictionary<System.String, System.String> RequestAttribute { get; set; }
public System.String ResponseContentType { get; set; }
public System.String SessionId { get; set; }
public List<Amazon.LexRuntimeV2.Model.ActiveContext> SessionStateValue_ActiveContext { get; set; }
public Amazon.LexRuntimeV2.StyleType DialogAction_SlotElicitationStyle { get; set; }
public System.String DialogAction_SlotToElicit { get; set; }
public Amazon.LexRuntimeV2.Model.ElicitSubSlot DialogAction_SubSlotToElicit { get; set; }
public Amazon.LexRuntimeV2.DialogActionType DialogAction_Type { get; set; }
public Amazon.LexRuntimeV2.ConfirmationState Intent_ConfirmationState { get; set; }
public System.String Intent_Name { get; set; }
public Dictionary<System.String, Amazon.LexRuntimeV2.Model.Slot> Intent_Slot { get; set; }
public Amazon.LexRuntimeV2.IntentState Intent_State { get; set; }
public System.String SessionStateValue_OriginatingRequestId { get; set; }
public Dictionary<System.String, Dictionary<System.String, Amazon.LexRuntimeV2.Model.RuntimeHintDetails>> RuntimeHints_SlotHint { get; set; }
public Dictionary<System.String, System.String> SessionStateValue_SessionAttribute { get; set; }
public System.Func<Amazon.LexRuntimeV2.Model.PutSessionResponse, WriteLRSV2SessionCmdlet, object> Select { get; set; } =
(response, cmdlet) => response;
}
}
}