System.Text.StringBuilder.Append(object)

public static string GenerateRoutes(IEnumerable<RouteInfo> infos)
        {
            StringBuilder sb = new StringBuilder();
            var group = infos.GroupBy(o => o.Namespace);
            sb.AppendLine($"using {typeof(object).Namespace};");
            sb.AppendLine($"using {typeof(Dictionary<int, int>).Namespace};");

            sb.AppendLine();
            for (int i = 0; i < group.Count(); i++)
            {
                sb.Append(GenerateNamespace(group.ElementAt(i), i == (group.Count() - 1)));
            }

            return sb.ToString();
        }

private static StringBuilder GenerateNamespace(IGrouping<string, RouteInfo> namespaceGroup, bool isLast)
        {
            StringBuilder sb = new StringBuilder();
            sb.AppendLine($"namespace {GetConvertedNamespace(namespaceGroup.Key)}");
            sb.AppendLine("{");

            var group = namespaceGroup.GroupBy(o => o.ControllerName);
            for (int i = 0; i < group.Count(); i++)
            {
                sb.Append(GenerateClreplaced(group.ElementAt(i), i == (group.Count() - 1)));
            }

            sb.AppendLine("}");
            if (!isLast)
            {
                sb.AppendLine();
            }

            return sb;
        }

public static string GenerateRoutes(IList<RouteInfo> infos)
        {
            StringBuilder sb = new StringBuilder();
            var group = infos.GroupBy(o => o.Namespace);
            sb.AppendLine($"using {typeof(object).Namespace};");
            sb.AppendLine($"using {typeof(Dictionary<int, int>).Namespace};");
            sb.AppendLine($"using {typeof(Task).Namespace};");
            sb.AppendLine($"using {typeof(HttpClientAsync).Namespace};");

            sb.AppendLine();
            for (int i = 0; i < group.Count(); i++)
            {
                sb.Append(GenerateNamespace(group.ElementAt(i), i == (group.Count() - 1)));
            }

            return sb.ToString();
        }

private void BuildInsertSql()
    {
        var sb = new StringBuilder();
        sb.Append("INSERT INTO {0} ");
        sb.Append("(");

        var valuesSql = new StringBuilder();
        var primaryKey = _descriptor.PrimaryKey;
        var dbAdapter = _descriptor.DbContext.Adapter;

        foreach (var col in _descriptor.Columns)
        {
            //排除自增主键
            if (col.IsPrimaryKey && (primaryKey.IsInt || primaryKey.IsLong))
                continue;

            dbAdapter.AppendQuote(sb, col.Name);
            sb.Append(",");

            dbAdapter.AppendParameter(valuesSql, col.PropertyName);

            //针对PostgreSQL数据库的json和jsonb类型字段的处理
            if (dbAdapter.Provider == DbProvider.PostgreSQL)
            {
                if (col.TypeName.EqualsIgnoreCase("jsonb"))
                {
                    valuesSql.Append("::jsonb");
                }
                else if (col.TypeName.EqualsIgnoreCase("json"))
                {
                    valuesSql.Append("::json");
                }
            }

            valuesSql.Append(",");
        }

        //删除最后一个","
        sb.Remove(sb.Length - 1, 1);

        sb.Append(") VALUES");

        //设置批量删除
        _sql.SetBatchAdd(sb.ToString());

        sb.Append("(");

        //删除最后一个","
        if (valuesSql.Length > 0)
            valuesSql.Remove(valuesSql.Length - 1, 1);

        sb.Append(valuesSql);
        sb.Append(")");

        if (dbAdapter.Provider != DbProvider.PostgreSQL)
        {
            sb.Append(";");
        }

        _sql.SetAdd(sb.ToString());
    }

public void Line(params string[] parts)
		{
			if (parts.Length != 0)
			{
				_sourceBuilder.Append(_indentPrefix);

				foreach (var s in parts)
				{
					_sourceBuilder.Append(s);
				}
			}

			_sourceBuilder.AppendLine();
		}

public override string ToString()
		{
			StringBuilder b = new StringBuilder("[Stack");
			foreach (T val in this) {
				b.Append(' ');
				b.Append(val);
			}
			b.Append(']');
			return b.ToString();
		}

private static string GenerateObjectTraceMessage(List<Type> objTrace)
            {
                var result = new StringBuilder();

                foreach (var objType in objTrace)
                {
                    if (result.Length != 0)
                    {
                        result.Append(" -> ");
                    }

                    result.Append(objType);
                }

                result.AppendLine();
                return $"Unity Coroutine Object Trace: {result}";
            }

public string GetHeaderText(IEnumerable<ModelItem> variableModels) {
			// Inject namespace imports
			var headerText = new StringBuilder();
			headerText.AppendLine(@"Imports System
Imports System.Collections
Imports System.Collections.Generic
Imports System.Linq");

			// NOTE: Automated IntelliPrompt will only show for namespaces and types that are within the imported namespaces...
			//       Add other namespace imports here if types from other namespaces should be accessible

			// Inject a Clreplaced and Sub wrapper
			headerText.AppendLine();
			headerText.AppendLine(@"Shared Clreplaced Expression
Shared Sub ExpressionValue");

			// Append variable declarations so they appear in IntelliPrompt
			if (variableModels != null) {
				foreach (var variableModel in variableModels) {
					if (variableModel != null) {
						var variable = variableModel.GetCurrentValue() as LocationReference;
						if (variable != null) {
							// Build a VB representation of the variable's type name
							var variableTypeName = new StringBuilder();
							AppendTypeName(variableTypeName, variable.Type);

							headerText.Append("Dim ");
							headerText.Append(variable.Name);
							headerText.Append(" As ");
							headerText.Append(variableTypeName.Replace("[", "(").Replace("]", ")"));
							headerText.AppendLine();
						}
					}
				}
			}

			// Since the doreplacedent text is an expression, inject a Return statement start at the end of the header text
			headerText.AppendLine();
			headerText.Append("Return ");

			return headerText.ToString();
		}

void SerializeOther(object value) {
				// NOTE: decimals lose precision during serialization.
				// They always have, I'm just letting you know.
				// Previously floats and doubles lost precision too.
				if (value is float) {
					builder.Append(((float) value).ToString("R"));
				} else if (value is int
				           || value is uint
				           || value is long
				           || value is sbyte
				           || value is byte
				           || value is short
				           || value is ushort
				           || value is ulong) {
					builder.Append(value);
				} else if (value is double
				           || value is decimal) {
					builder.Append(Convert.ToDouble(value).ToString("R"));
				} else {
					SerializeString(value.ToString());
				}
			}

private static IEnumerable<IToken> Lex(CodeFile file, Diagnostics diagnostics)
        {
            var code = file.Code;
            var text = code.Text;
            var tokenStart = 0;
            var tokenEnd = -1; // One past the end position to allow for zero length spans
            while (tokenStart < text.Length)
            {
                var currentChar = text[tokenStart];
                switch (currentChar)
                {
                    case '{':
                        yield return TokenFactory.OpenBrace(SymbolSpan());
                        break;
                    case '}':
                        yield return TokenFactory.CloseBrace(SymbolSpan());
                        break;
                    case '(':
                        yield return TokenFactory.OpenParen(SymbolSpan());
                        break;
                    case ')':
                        yield return TokenFactory.CloseParen(SymbolSpan());
                        break;
                    case '[':
                    case ']':
                    case '|':
                    case '&':
                    case '@':
                    case '`':
                    case '$':
                        yield return NewReservedOperator();
                        break;
                    case ';':
                        yield return TokenFactory.Semicolon(SymbolSpan());
                        break;
                    case ',':
                        yield return TokenFactory.Comma(SymbolSpan());
                        break;
                    case '#':
                        switch (NextChar())
                        {
                            case '#':
                                // it is `##`
                                yield return NewReservedOperator(2);
                                break;
                            case '(':
                                // it is `#(`
                                yield return NewReservedOperator(2);
                                break;
                            case '[':
                                // it is `#[`
                                yield return NewReservedOperator(2);
                                break;
                            case '{':
                                // it is `#{`
                                yield return NewReservedOperator(2);
                                break;
                            default:
                                // it is `#`
                                yield return NewReservedOperator();
                                break;
                        }
                        break;
                    case '.':
                        if (NextChar() is '.')
                        {
                            if (CharAt(2) is '<')
                                // it is `..<`
                                yield return TokenFactory.DotDotLessThan(SymbolSpan(3));
                            else
                                // it is `..`
                                yield return TokenFactory.DotDot(SymbolSpan(2));
                        }
                        else
                            yield return TokenFactory.Dot(SymbolSpan());
                        break;
                    case ':':
                        if (NextChar() is ':' && CharAt(2) is '.')
                            // it is `::.`
                            yield return TokenFactory.ColonColonDot(SymbolSpan(3));
                        else
                            // it is `:`
                            yield return TokenFactory.Colon(SymbolSpan());
                        break;
                    case '?':
                        switch (NextChar())
                        {
                            case '?':
                                // it is `??`
                                yield return TokenFactory.QuestionQuestion(SymbolSpan(2));
                                break;
                            case '.':
                                // it is `?.`
                                yield return TokenFactory.QuestionDot(SymbolSpan(2));
                                break;
                            default:
                                // it is `?`
                                yield return TokenFactory.Question(SymbolSpan());
                                break;
                        }
                        break;
                    case '→':
                        yield return TokenFactory.RightArrow(SymbolSpan());
                        break;
                    case '⇒':
                        yield return TokenFactory.RightDoubleArrow(SymbolSpan());
                        break;
                    case '⬿':
                        yield return TokenFactory.LeftWaveArrow(SymbolSpan());
                        break;
                    case '⤳':
                        yield return TokenFactory.RightWaveArrow(SymbolSpan());
                        break;
                    case '^':
                        if (NextChar() is '.')
                            // it is `^.`
                            yield return NewReservedOperator(2);
                        else
                            // it is `^`
                            yield return NewReservedOperator();
                        break;
                    case '+':
                        if (NextChar() is '=')
                            // it is `+=`
                            yield return TokenFactory.PlusEquals(SymbolSpan(2));
                        else
                            // it is `+`
                            yield return TokenFactory.Plus(SymbolSpan());
                        break;
                    case '-':
                        switch (NextChar())
                        {
                            case '=':
                                // it is `-=`
                                yield return TokenFactory.MinusEquals(SymbolSpan(2));
                                break;
                            case '>':
                                // it is `->`
                                yield return TokenFactory.RightArrow(SymbolSpan(2));
                                break;
                            default:
                                // it is `-`
                                yield return TokenFactory.Minus(SymbolSpan());
                                break;
                        }
                        break;
                    case '~':
                        if (NextChar() is '>')
                            // it is `~>`
                            yield return TokenFactory.RightWaveArrow(SymbolSpan(2));
                        else
                        {
                            // it is `~` which isn't allowed
                            yield return NewUnexpectedCharacter();
                        }
                        break;
                    case '*':
                        if (NextChar() is '=')
                            // it is `*=`
                            yield return TokenFactory.AsteriskEquals(SymbolSpan(2));
                        else
                            // it is `*`
                            yield return TokenFactory.Asterisk(SymbolSpan());

                        break;
                    case '/':
                        switch (NextChar())
                        {
                            case '/':
                                // it is a line comment `//`
                                tokenEnd = tokenStart + 2;
                                // Include newline at end
                                while (tokenEnd < text.Length)
                                {
                                    currentChar = text[tokenEnd];
                                    tokenEnd += 1;
                                    if (currentChar == '\r' || currentChar == '\n')
                                        break;
                                }

                                yield return TokenFactory.Comment(TokenSpan());
                                break;
                            case '*':
                                // it is a block comment `/*`
                                tokenEnd = tokenStart + 2;
                                var lastCharWreplacedtar = false;
                                // Include slash at end
                                for (; ; )
                                {
                                    // If we ran into the end of the file, error
                                    if (tokenEnd >= text.Length)
                                    {
                                        diagnostics.Add(LexError.UnclosedBlockComment(file,
                                            TextSpan.FromStartEnd(tokenStart, tokenEnd)));
                                        break;
                                    }
                                    currentChar = text[tokenEnd];
                                    tokenEnd += 1;
                                    if (lastCharWreplacedtar && currentChar == '/')
                                        break;
                                    lastCharWreplacedtar = currentChar == '*';
                                }

                                yield return TokenFactory.Comment(TokenSpan());
                                break;
                            case '=':
                                // it is `/=`
                                yield return TokenFactory.SlashEquals(SymbolSpan(2));
                                break;
                            default:
                                // it is `/`
                                yield return TokenFactory.Slash(SymbolSpan());
                                break;
                        }
                        break;
                    case '=':
                        switch (NextChar())
                        {
                            case '>':
                                // it is `=>`
                                yield return TokenFactory.RightDoubleArrow(SymbolSpan(2));
                                break;
                            case '=':
                                // it is `==`
                                yield return TokenFactory.EqualsEquals(SymbolSpan(2));
                                break;
                            case '/':
                                if (CharAt(2) is '=')
                                    // it is `=/=`
                                    yield return TokenFactory.NotEqual(SymbolSpan(3));
                                else
                                    goto default;
                                break;
                            default:
                                // it is `=`
                                yield return TokenFactory.Equals(SymbolSpan());
                                break;
                        }
                        break;
                    case '≠':
                        yield return TokenFactory.NotEqual(SymbolSpan());
                        break;
                    case '>':
                        if (NextChar() is '=')
                            // it is `>=`
                            yield return TokenFactory.GreaterThanOrEqual(SymbolSpan(2));
                        else
                            // it is `>`
                            yield return TokenFactory.GreaterThan(SymbolSpan());
                        break;
                    case '≥':
                        yield return TokenFactory.GreaterThanOrEqual(SymbolSpan());
                        break;
                    case '<':
                        switch (NextChar())
                        {
                            case '=':
                                // it is `<=`
                                yield return TokenFactory.LessThanOrEqual(SymbolSpan(2));
                                break;
                            case ':':
                                // it is `<:`
                                yield return TokenFactory.LessThanColon(SymbolSpan(2));
                                break;
                            case '~':
                                // it is `<~`
                                yield return TokenFactory.LeftWaveArrow(SymbolSpan(2));
                                break;
                            case '.':
                                if (CharAt(2) is '.')
                                {
                                    if (CharAt(3) is '<')
                                        // it is `<..<`
                                        yield return TokenFactory.LessThanDotDotLessThan(SymbolSpan(4));
                                    else
                                        // it is `<..`
                                        yield return TokenFactory.LessThanDotDot(SymbolSpan(3));
                                }
                                else
                                    goto default;
                                break;
                            default:
                                // it is `<`
                                yield return TokenFactory.LessThan(SymbolSpan());
                                break;
                        }
                        break;
                    case '≤':
                        yield return TokenFactory.LessThanOrEqual(SymbolSpan());
                        break;
                    case '"':
                        yield return LexString();
                        break;
                    case '0':
                    case '1':
                    case '2':
                    case '3':
                    case '4':
                    case '5':
                    case '6':
                    case '7':
                    case '8':
                    case '9':
                    {
                        tokenEnd = tokenStart + 1;
                        while (tokenEnd < text.Length && IsIntegerCharacter(text[tokenEnd]))
                            tokenEnd += 1;

                        var span = TokenSpan();
                        var value = BigInteger.Parse(code[span], CultureInfo.InvariantCulture);
                        yield return TokenFactory.IntegerLiteral(span, value);
                        break;
                    }
                    case '\\':
                    {
                        tokenEnd = tokenStart + 1;
                        while (tokenEnd < text.Length && IsIdentifierCharacter(text[tokenEnd]))
                            tokenEnd += 1;

                        if (tokenEnd == tokenStart + 1)
                            yield return NewUnexpectedCharacter();
                        else
                            yield return NewEscapedIdentifier();
                        break;
                    }
                    default:
                        if (char.IsWhiteSpace(currentChar))
                        {
                            tokenEnd = tokenStart + 1;
                            // Include whitespace at end
                            while (tokenEnd < text.Length && char.IsWhiteSpace(text[tokenEnd]))
                                tokenEnd += 1;

                            yield return TokenFactory.Whitespace(TokenSpan());
                        }
                        else if (IsIdentifierStartCharacter(currentChar))
                        {
                            tokenEnd = tokenStart + 1;
                            while (tokenEnd < text.Length && IsIdentifierCharacter(text[tokenEnd]))
                                tokenEnd += 1;

                            yield return NewIdentifierOrKeywordToken();
                        }
                        else if (currentChar == '!' && NextChar() is '=')
                        {
                            var span = SymbolSpan(2);
                            diagnostics.Add(LexError.CStyleNotEquals(file, span));
                            yield return TokenFactory.NotEqual(span);
                        }
                        else
                            yield return NewUnexpectedCharacter();

                        break;
                }
                tokenStart = tokenEnd;
            }

            // The end of file token provides something to attach any final errors to
            yield return TokenFactory.EndOfFile(SymbolSpan(0));
            yield break;

            TextSpan SymbolSpan(int length = 1)
            {
                var end = tokenStart + length;
                return TokenSpan(end);
            }
            TextSpan TokenSpan(int? end = null)
            {
                tokenEnd = end ?? tokenEnd;
                return TextSpan.FromStartEnd(tokenStart, tokenEnd);
            }

            IToken NewIdentifierOrKeywordToken()
            {
                var span = TokenSpan();
                var value = code[span];
                if (TokenTypes.KeywordFactories.TryGetValue(value, out var keywordFactory))
                    return keywordFactory(span);

                if (value == "continue")
                    diagnostics.Add(LexError.ContinueInsteadOfNext(file, span));
                else if (TokenTypes.ReservedWords.Contains(value)
                    || TokenTypes.IsReservedTypeName(value))
                    diagnostics.Add(LexError.ReservedWord(file, span, value));

                return TokenFactory.BareIdentifier(span, value);
            }
            IToken NewEscapedIdentifier()
            {
                var identifierStart = tokenStart + 1;
                var span = TokenSpan();
                var value = text[identifierStart..tokenEnd];
                var isValidToEscape = TokenTypes.Keywords.Contains(value)
                                      || TokenTypes.ReservedWords.Contains(value)
                                      || TokenTypes.IsReservedTypeName(value)
                                      || char.IsDigit(value[0]);
                if (!isValidToEscape)
                    diagnostics.Add(LexError.EscapedIdentifierShouldNotBeEscaped(file, span, value));
                return TokenFactory.EscapedIdentifier(span, value);
            }
            IToken NewUnexpectedCharacter()
            {
                var span = SymbolSpan();
                var value = code[span];
                diagnostics.Add(LexError.UnexpectedCharacter(file, span, value[0]));
                return TokenFactory.Unexpected(span);
            }
            IToken NewReservedOperator(int length = 1)
            {
                var span = SymbolSpan(length);
                var value = code[span];
                diagnostics.Add(LexError.ReservedOperator(file, span, value));
                return TokenFactory.Unexpected(span);
            }

            char? NextChar()
            {
                var index = tokenStart + 1;
                return index < text.Length ? text[index] : default;
            }

            char? CharAt(int offset)
            {
                var index = tokenStart + offset;
                return index < text.Length ? text[index] : default;
            }

            IToken LexString()
            {
                tokenEnd = tokenStart + 1;
                var content = new StringBuilder();
                char currentChar;
                while (tokenEnd < text.Length && (currentChar = text[tokenEnd]) != '"')
                {
                    tokenEnd += 1;

                    if (currentChar != '\\')
                    {
                        content.Append(currentChar);
                        continue;
                    }

                    // Escape Sequence (i.e. "\\")
                    // In case of an invalid escape sequence, we just drop the `\` from the value

                    if (tokenEnd >= text.Length)
                    {
                        // Just the slash is invalid
                        var errorSpan = TextSpan.FromStartEnd(tokenEnd - 1, tokenEnd);
                        diagnostics.Add(LexError.InvalidEscapeSequence(file, errorSpan));
                        break; // we hit the end of file and need to not add to tokenEnd any more
                    }

                    // Escape Sequence with next char (i.e. "\\x")
                    var escapeStart = tokenEnd - 1;
                    currentChar = text[tokenEnd];
                    tokenEnd += 1;
                    switch (currentChar)
                    {
                        case '"':
                        case '\'':
                        case '\\':
                            content.Append(currentChar);
                            break;
                        case 'n':
                            content.Append('\n');
                            break;
                        case 'r':
                            content.Append('\r');
                            break;
                        case '0':
                            content.Append('\0');
                            break;
                        case 't':
                            content.Append('\t');
                            break;
                        case 'u':
                        {
                            if (tokenEnd < text.Length && text[tokenEnd] == '(')
                                tokenEnd += 1;
                            else
                            {
                                content.Append('u');
                                var errorSpan = TextSpan.FromStartEnd(escapeStart, tokenEnd);
                                diagnostics.Add(LexError.InvalidEscapeSequence(file, errorSpan));
                                break;
                            }

                            var codepoint = new StringBuilder(6);
                            while (tokenEnd < text.Length &&
                                   IsHexDigit(currentChar = text[tokenEnd]))
                            {
                                codepoint.Append(currentChar);
                                tokenEnd += 1;
                            }

                            int value;
                            if (codepoint.Length > 0
                                && codepoint.Length <= 6
                                && (value = Convert.ToInt32(codepoint.ToString(), 16)) <= 0x10FFFF)
                            {
                                // TODO disallow surrogate pairs
                                content.Append(char.ConvertFromUtf32(value));
                            }
                            else
                            {
                                content.Append("u(");
                                content.Append(codepoint);
                                // Include the closing ')' in the escape sequence if it is present
                                if (tokenEnd < text.Length && text[tokenEnd] == ')')
                                {
                                    content.Append(')');
                                    tokenEnd += 1;
                                }
                                var errorSpan = TextSpan.FromStartEnd(escapeStart, tokenEnd);
                                diagnostics.Add(LexError.InvalidEscapeSequence(file, errorSpan));
                                break;
                            }

                            if (tokenEnd < text.Length && text[tokenEnd] == ')')
                                tokenEnd += 1;
                            else
                            {
                                var errorSpan = TextSpan.FromStartEnd(escapeStart, tokenEnd);
                                diagnostics.Add(LexError.InvalidEscapeSequence(file, errorSpan));
                            }
                            break;
                        }
                        default:
                        {
                            // Last two chars form the invalid sequence
                            var errorSpan = TextSpan.FromStartEnd(tokenEnd - 2, tokenEnd);
                            diagnostics.Add(LexError.InvalidEscapeSequence(file, errorSpan));
                            // drop the `/` keep the character after
                            content.Append(currentChar);
                            break;
                        }
                    }
                }

                if (tokenEnd < text.Length)
                {
                    // To include the close quote
                    if (text[tokenEnd] == '"')
                        tokenEnd += 1;
                }
                else
                    diagnostics.Add(LexError.UnclosedStringLiteral(file,
                        TextSpan.FromStartEnd(tokenStart, tokenEnd)));

                return TokenFactory.StringLiteral(TextSpan.FromStartEnd(tokenStart, tokenEnd), content.ToString());
            }
        }

protected virtual void AppendLogScope(StringBuilder sb, object scope)
        {
            sb.Append("=> ").Append(scope);
        }

public virtual Task WriteAsync(object obj = null)
        {
            this.stringBuilder.Append(obj);
            return Task.CompletedTask;
        }

public virtual Task WriteAttributeValueAsync(string prefix, int prefixOffset, object value, int valueOffset, int valueLength, bool isLiteral)
        {
            this.stringBuilder.Append(prefix);
            this.stringBuilder.Append(value);
            return Task.CompletedTask;
        }

public override string ToString()  {
      var sb = new StringBuilder();
      sb.Append("clreplaced Amount {\n");
      sb.Append("  Currency: ").Append(Currency).Append("\n");
      sb.Append("  Value: ").Append(Value).Append("\n");
      sb.Append("}\n");
      return sb.ToString();
    }

public override string ToString()  {
      var sb = new StringBuilder();
      sb.Append("clreplaced CardBin {\n");
      sb.Append("  Bin: ").Append(Bin).Append("\n");
      sb.Append("  Commercial: ").Append(Commercial).Append("\n");
      sb.Append("  FundingSource: ").Append(FundingSource).Append("\n");
      sb.Append("  FundsAvailability: ").Append(FundsAvailability).Append("\n");
      sb.Append("  IssuingBank: ").Append(IssuingBank).Append("\n");
      sb.Append("  IssuingCountry: ").Append(IssuingCountry).Append("\n");
      sb.Append("  IssuingCurrency: ").Append(IssuingCurrency).Append("\n");
      sb.Append("  PaymentMethod: ").Append(PaymentMethod).Append("\n");
      sb.Append("  PayoutEligible: ").Append(PayoutEligible).Append("\n");
      sb.Append("  Summary: ").Append(Summary).Append("\n");
      sb.Append("}\n");
      return sb.ToString();
    }

public override string ToString()  {
      var sb = new StringBuilder();
      sb.Append("clreplaced CostEstimatereplacedumptions {\n");
      sb.Append("  replacedume3DSecureAuthenticated: ").Append(replacedume3DSecureAuthenticated).Append("\n");
      sb.Append("  replacedumeLevel3Data: ").Append(replacedumeLevel3Data).Append("\n");
      sb.Append("  Installments: ").Append(Installments).Append("\n");
      sb.Append("}\n");
      return sb.ToString();
    }

public override string ToString()
        {
            var sb = new StringBuilder();
            sb.Append("clreplaced ThreeDSAvailabilityRequest {\n");
            sb.Append("  AdditionalData: ").Append(AdditionalData).Append("\n");
            sb.Append("  Brands: ").Append(Brands).Append("\n");
            sb.Append("  CardNumber: ").Append(CardNumber).Append("\n");
            sb.Append("  MerchantAccount: ").Append(MerchantAccount).Append("\n");
            sb.Append("  RecurringDetailReference: ").Append(RecurringDetailReference).Append("\n");
            sb.Append("  ShopperReference: ").Append(ShopperReference).Append("\n");
            sb.Append("}\n");
            return sb.ToString();
        }

public override string ToString()
        {
            var sb = new StringBuilder();
            sb.Append("clreplaced GooglePayDetails {\n");
            sb.Append("  FundingSource: ").Append(FundingSource).Append("\n");
            sb.Append("  GooglePayCardNetwork: ").Append(GooglePayCardNetwork).Append("\n");
            sb.Append("  GooglePayToken: ").Append(GooglePayToken).Append("\n");
            sb.Append("  Type: ").Append(Type).Append("\n");
            sb.Append("}\n");
            return sb.ToString();
        }

public override string ToString()
        {
            var sb = new StringBuilder();
            sb.Append("clreplaced MasterpreplacedDetails {\n");
            sb.Append("  FundingSource: ").Append(FundingSource).Append("\n");
            sb.Append("  MasterpreplacedTransactionId: ").Append(MasterpreplacedTransactionId).Append("\n");
            sb.Append("  Type: ").Append(Type).Append("\n");
            sb.Append("}\n");
            return sb.ToString();
        }

public override string ToString()
        {
            var sb = new StringBuilder();
            sb.Append("clreplaced PayPalDetails {\n");
            sb.Append("  Subtype: ").Append(Subtype).Append("\n");
            sb.Append("  Type: ").Append(Type).Append("\n");
            sb.Append("}\n");
            return sb.ToString();
        }

public override string ToString()
        {
            var sb = new StringBuilder();
            sb.Append("clreplaced SamsungPayDetails {\n");
            sb.Append("  FundingSource: ").Append(FundingSource).Append("\n");
            sb.Append("  SamsungPayToken: ").Append(SamsungPayToken).Append("\n");
            sb.Append("  Type: ").Append(Type).Append("\n");
            sb.Append("}\n");
            return sb.ToString();
        }

public override string ToString()
        {
            var sb = new StringBuilder();
            sb.Append("clreplaced BrowserInfo {\n");
            sb.Append("  AcceptHeader: ").Append(AcceptHeader).Append("\n");
            sb.Append("  ColorDepth: ").Append(ColorDepth).Append("\n");
            sb.Append("  JavaEnabled: ").Append(JavaEnabled).Append("\n");
            sb.Append("  JavaScriptEnabled: ").Append(JavaScriptEnabled).Append("\n");
            sb.Append("  Language: ").Append(Language).Append("\n");
            sb.Append("  ScreenHeight: ").Append(ScreenHeight).Append("\n");
            sb.Append("  ScreenWidth: ").Append(ScreenWidth).Append("\n");
            sb.Append("  TimeZoneOffset: ").Append(TimeZoneOffset).Append("\n");
            sb.Append("  UserAgent: ").Append(UserAgent).Append("\n");
            sb.Append("}\n");
            return sb.ToString();
        }

public override string ToString()
        {
            var sb = new StringBuilder();
            sb.Append("clreplaced CardDetails {\n");
            sb.Append("  Brand: ").Append(Brand).Append("\n");
            sb.Append("  CupsecureplusSmscode: ").Append(CupsecureplusSmscode).Append("\n");
            sb.Append("  Cvc: ").Append(Cvc).Append("\n");
            sb.Append("  EncryptedCardNumber: ").Append(EncryptedCardNumber).Append("\n");
            sb.Append("  EncryptedExpiryMonth: ").Append(EncryptedExpiryMonth).Append("\n");
            sb.Append("  EncryptedExpiryYear: ").Append(EncryptedExpiryYear).Append("\n");
            sb.Append("  ExpiryMonth: ").Append(ExpiryMonth).Append("\n");
            sb.Append("  ExpiryYear: ").Append(ExpiryYear).Append("\n");
            sb.Append("  FundingSource: ").Append(FundingSource).Append("\n");
            sb.Append("  HolderName: ").Append(HolderName).Append("\n");
            sb.Append("  Number: ").Append(Number).Append("\n");
            sb.Append("  RecurringDetailReference: ").Append(RecurringDetailReference).Append("\n");
            sb.Append("  StoredPaymentMethodId: ").Append(StoredPaymentMethodId).Append("\n");
            sb.Append("  Type: ").Append(Type).Append("\n");
            sb.Append("}\n");
            return sb.ToString();
        }

public override string ToString()
        {
            var sb = new StringBuilder();
            sb.Append("clreplaced Configuration {\n");
            sb.Append("  Avs: ").Append(Avs).Append("\n");
            sb.Append("  CardHolderName: ").Append(CardHolderName).Append("\n");
            sb.Append("  Installments: ").Append(Installments).Append("\n");
            sb.Append("  ShopperInput: ").Append(ShopperInput).Append("\n");
            sb.Append("}\n");
            return sb.ToString();
        }

public override string ToString()
        {
            var sb = new StringBuilder();
            sb.Append("clreplaced FraudResult {\n");
            sb.Append("  AccountScore: ").Append(AccountScore).Append("\n");
            sb.Append("  Results: ").Append(Results.ObjectListToString()).Append("\n");
            sb.Append("}\n");
            return sb.ToString();
        }

public override string ToString()
        {
            var sb = new StringBuilder();
            sb.Append("clreplaced PaymentLinkResource {\n");
            sb.Append("  AllowedPaymentMethods: ").Append(AllowedPaymentMethods.ToListString()).Append("\n");
            sb.Append("  Amount: ").Append(Amount).Append("\n");
            sb.Append("  ApplicationInfo: ").Append(ApplicationInfo).Append("\n");
            sb.Append("  BillingAddress: ").Append(BillingAddress).Append("\n");
            sb.Append("  BlockedPaymentMethods: ").Append(BlockedPaymentMethods.ToListString()).Append("\n");
            sb.Append("  CountryCode: ").Append(CountryCode).Append("\n");
            sb.Append("  DeliverAt: ").Append(DeliverAt).Append("\n");
            sb.Append("  DeliveryAddress: ").Append(DeliveryAddress).Append("\n");
            sb.Append("  Description: ").Append(Description).Append("\n");
            sb.Append("  ExpiresAt: ").Append(ExpiresAt).Append("\n");
            sb.Append("  Id: ").Append(Id).Append("\n");
            sb.Append("  LineItems: ").Append(LineItems.ObjectListToString()).Append("\n");
            sb.Append("  MerchantAccount: ").Append(MerchantAccount).Append("\n");
            sb.Append("  MerchantOrderReference: ").Append(MerchantOrderReference).Append("\n");
            sb.Append("  RecurringProcessingModel: ").Append(RecurringProcessingModel).Append("\n");
            sb.Append("  Reference: ").Append(Reference).Append("\n");
            sb.Append("  ReturnUrl: ").Append(ReturnUrl).Append("\n");
            sb.Append("  Reusable: ").Append(Reusable).Append("\n");
            sb.Append("  RiskData: ").Append(RiskData).Append("\n");
            sb.Append("  ShopperEmail: ").Append(ShopperEmail).Append("\n");
            sb.Append("  ShopperLocale: ").Append(ShopperLocale).Append("\n");
            sb.Append("  ShopperName: ").Append(ShopperName).Append("\n");
            sb.Append("  ShopperReference: ").Append(ShopperReference).Append("\n");
            sb.Append("  Splits: ").Append(Splits.ObjectListToString()).Append("\n");
            sb.Append("  Status: ").Append(Status).Append("\n");
            sb.Append("  Store: ").Append(Store).Append("\n");
            sb.Append("  StorePaymentMethod: ").Append(StorePaymentMethod).Append("\n");
            sb.Append("  Url: ").Append(Url).Append("\n");
            sb.Append("}\n");
            return sb.ToString();
        }

public override string ToString()  {
      var sb = new StringBuilder();
      sb.Append("clreplaced DSPublicKeyDetail {\n");
      sb.Append("  Brand: ").Append(Brand).Append("\n");
      sb.Append("  DirectoryServerId: ").Append(DirectoryServerId).Append("\n");
      sb.Append("  PublicKey: ").Append(PublicKey).Append("\n");
      sb.Append("}\n");
      return sb.ToString();
    }

public override string ToString()  {
      var sb = new StringBuilder();
      sb.Append("clreplaced MerchantDetails {\n");
      sb.Append("  CountryCode: ").Append(CountryCode).Append("\n");
      sb.Append("  EnrolledIn3DSecure: ").Append(EnrolledIn3DSecure).Append("\n");
      sb.Append("  Mcc: ").Append(Mcc).Append("\n");
      sb.Append("}\n");
      return sb.ToString();
    }

public override string ToString()  {
      var sb = new StringBuilder();
      sb.Append("clreplaced Recurring {\n");
      sb.Append("  Contract: ").Append(Contract).Append("\n");
      sb.Append("  RecurringDetailName: ").Append(RecurringDetailName).Append("\n");
      sb.Append("  RecurringExpiry: ").Append(RecurringExpiry).Append("\n");
      sb.Append("  RecurringFrequency: ").Append(RecurringFrequency).Append("\n");
      sb.Append("  TokenService: ").Append(TokenService).Append("\n");
      sb.Append("}\n");
      return sb.ToString();
    }

public override string ToString()
        {
            var sb = new StringBuilder();
            sb.Append("clreplaced VisaCheckoutDetails {\n");
            sb.Append("  FundingSource: ").Append(FundingSource).Append("\n");
            sb.Append("  Type: ").Append(Type).Append("\n");
            sb.Append("  VisaCheckoutCallId: ").Append(VisaCheckoutCallId).Append("\n");
            sb.Append("}\n");
            return sb.ToString();
        }

public override string ToString()
        {
            var sb = new StringBuilder();
            sb.Append("clreplaced AccountInfo {\n");
            sb.Append("  AccountAgeIndicator: ").Append(AccountAgeIndicator).Append("\n");
            sb.Append("  AccountChangeDate: ").Append(AccountChangeDate).Append("\n");
            sb.Append("  AccountChangeIndicator: ").Append(AccountChangeIndicator).Append("\n");
            sb.Append("  AccountCreationDate: ").Append(AccountCreationDate).Append("\n");
            sb.Append("  AccountType: ").Append(AccountType).Append("\n");
            sb.Append("  AddCardAttemptsDay: ").Append(AddCardAttemptsDay).Append("\n");
            sb.Append("  DeliveryAddressUsageDate: ").Append(DeliveryAddressUsageDate).Append("\n");
            sb.Append("  DeliveryAddressUsageIndicator: ").Append(DeliveryAddressUsageIndicator).Append("\n");
            sb.Append("  HomePhone: ").Append(HomePhone).Append("\n");
            sb.Append("  MobilePhone: ").Append(MobilePhone).Append("\n");
            sb.Append("  PreplacedwordChangeDate: ").Append(PreplacedwordChangeDate).Append("\n");
            sb.Append("  PreplacedwordChangeIndicator: ").Append(PreplacedwordChangeIndicator).Append("\n");
            sb.Append("  PastTransactionsDay: ").Append(PastTransactionsDay).Append("\n");
            sb.Append("  PastTransactionsYear: ").Append(PastTransactionsYear).Append("\n");
            sb.Append("  PaymentAccountAge: ").Append(PaymentAccountAge).Append("\n");
            sb.Append("  PaymentAccountIndicator: ").Append(PaymentAccountIndicator).Append("\n");
            sb.Append("  PurchasesLast6Months: ").Append(PurchasesLast6Months).Append("\n");
            sb.Append("  SuspiciousActivity: ").Append(SuspiciousActivity).Append("\n");
            sb.Append("  WorkPhone: ").Append(WorkPhone).Append("\n");
            sb.Append("}\n");
            return sb.ToString();
        }

public override string ToString()
        {
            var sb = new StringBuilder();
            sb.Append("clreplaced CheckoutCreateOrderResponse {\n");
            sb.Append("  AdditionalData: ").Append(AdditionalData.ToCollectionsString()).Append("\n");
            sb.Append("  Amount: ").Append(Amount).Append("\n");
            sb.Append("  ExpiresAt: ").Append(ExpiresAt).Append("\n");
            sb.Append("  FraudResult: ").Append(FraudResult).Append("\n");
            sb.Append("  OrderData: ").Append(OrderData).Append("\n");
            sb.Append("  PspReference: ").Append(PspReference).Append("\n");
            sb.Append("  RefusalReason: ").Append(RefusalReason).Append("\n");
            sb.Append("  RemainingAmount: ").Append(RemainingAmount).Append("\n");
            sb.Append("  ResultCode: ").Append(ResultCode).Append("\n");
            sb.Append("}\n");
            return sb.ToString();
        }

public override string ToString()
        {
            var sb = new StringBuilder();
            sb.Append("clreplaced CreatePaymentLinkRequest {\n");
            sb.Append("  AllowedPaymentMethods: ").Append(AllowedPaymentMethods.ToListString()).Append("\n");
            sb.Append("  Amount: ").Append(Amount).Append("\n");
            sb.Append("  ApplicationInfo: ").Append(ApplicationInfo).Append("\n");
            sb.Append("  BillingAddress: ").Append(BillingAddress).Append("\n");
            sb.Append("  BlockedPaymentMethods: ").Append(BlockedPaymentMethods).Append("\n");
            sb.Append("  CountryCode: ").Append(CountryCode).Append("\n");
            sb.Append("  DeliverAt: ").Append(DeliverAt).Append("\n");
            sb.Append("  DeliveryAddress: ").Append(DeliveryAddress).Append("\n");
            sb.Append("  Description: ").Append(Description).Append("\n");
            sb.Append("  ExpiresAt: ").Append(ExpiresAt).Append("\n");
            sb.Append("  InstallmentOptions: ").Append(InstallmentOptions.ToCollectionsString()).Append("\n");
            sb.Append("  LineItems: ").Append(LineItems.ObjectListToString()).Append("\n");
            sb.Append("  MerchantAccount: ").Append(MerchantAccount).Append("\n");
            sb.Append("  MerchantOrderReference: ").Append(MerchantOrderReference).Append("\n");
            sb.Append("  Metadata: ").Append(Metadata.ToCollectionsString()).Append("\n");
            sb.Append("  RecurringProcessingModel: ").Append(RecurringProcessingModel).Append("\n");
            sb.Append("  Reference: ").Append(Reference).Append("\n");
            sb.Append("  ReturnUrl: ").Append(ReturnUrl).Append("\n");
            sb.Append("  Reusable: ").Append(Reusable).Append("\n");
            sb.Append("  RiskData: ").Append(RiskData).Append("\n");
            sb.Append("  ShopperEmail: ").Append(ShopperEmail).Append("\n");
            sb.Append("  ShopperLocale: ").Append(ShopperLocale).Append("\n");
            sb.Append("  ShopperName: ").Append(ShopperName).Append("\n");
            sb.Append("  ShopperReference: ").Append(ShopperReference).Append("\n");
            sb.Append("  Splits: ").Append(Splits.ObjectListToString()).Append("\n");
            sb.Append("  Store: ").Append(Store).Append("\n");
            sb.Append("  StorePaymentMethod: ").Append(StorePaymentMethod).Append("\n");
            sb.Append("}\n");
            return sb.ToString();
        }

public override string ToString()
        {
            var sb = new StringBuilder();
            sb.Append("clreplaced ForexQuote {\n");
            sb.Append("  Account: ").Append(Account).Append("\n");
            sb.Append("  AccountType: ").Append(AccountType).Append("\n");
            sb.Append("  BaseAmount: ").Append(BaseAmount).Append("\n");
            sb.Append("  BasePoints: ").Append(BasePoints).Append("\n");
            sb.Append("  Buy: ").Append(Buy).Append("\n");
            sb.Append("  Interbank: ").Append(Interbank).Append("\n");
            sb.Append("  Reference: ").Append(Reference).Append("\n");
            sb.Append("  Sell: ").Append(Sell).Append("\n");
            sb.Append("  Signature: ").Append(Signature).Append("\n");
            sb.Append("  Source: ").Append(Source).Append("\n");
            sb.Append("  Type: ").Append(Type).Append("\n");
            sb.Append("  ValidTill: ").Append(ValidTill).Append("\n");
            sb.Append("}\n");
            return sb.ToString();
        }

public override string ToString()
        {
            var sb = new StringBuilder();
            sb.Append("clreplaced Installments {\n");
            sb.Append("  Plan: ").Append(Plan).Append("\n");
            sb.Append("  Value: ").Append(Value).Append("\n");
            sb.Append("}\n");
            return sb.ToString();
        }

public override string ToString()
        {
            var sb = new StringBuilder();
            sb.Append("clreplaced LineItem {\n");
            sb.Append("  AmountExcludingTax: ").Append(AmountExcludingTax).Append("\n");
            sb.Append("  AmountIncludingTax: ").Append(AmountIncludingTax).Append("\n");
            sb.Append("  Description: ").Append(Description).Append("\n");
            sb.Append("  Id: ").Append(Id).Append("\n");
            sb.Append("  ImageUrl: ").Append(ImageUrl).Append("\n");
            sb.Append("  ProductUrl: ").Append(ProductUrl).Append("\n");
            sb.Append("  Quanreplacedy: ").Append(Quanreplacedy).Append("\n");
            sb.Append("  TaxAmount: ").Append(TaxAmount).Append("\n");
            sb.Append("  TaxCategory: ").Append(TaxCategory).Append("\n");
            sb.Append("  TaxPercentage: ").Append(TaxPercentage).Append("\n");
            sb.Append("}\n");
            return sb.ToString();
        }

public override string ToString()
        {
            var sb = new StringBuilder();
            sb.Append("clreplaced ThreeDSAvailabilityResponse {\n");
            sb.Append("  BinDetails: ").Append(BinDetails).Append("\n");
            sb.Append("  DsPublicKeys: ").Append(DsPublicKeys).Append("\n");
            sb.Append("  ThreeDS1Supported: ").Append(ThreeDS1Supported).Append("\n");
            sb.Append("  ThreeDS2CardRangeDetails: ").Append(ThreeDS2CardRangeDetails).Append("\n");
            sb.Append("  ThreeDS2supported: ").Append(ThreeDS2supported).Append("\n");
            sb.Append("}\n");
            return sb.ToString();
        }

public override string ToString()
        {
            var sb = new StringBuilder();
            sb.Append("clreplaced CheckoutOneTimePreplacedcodeAction {\n");
            sb.Append("  PaymentData: ").Append(PaymentData).Append("\n");
            sb.Append("  PaymentMethodType: ").Append(PaymentMethodType).Append("\n");
            sb.Append("  Redirect: ").Append(Redirect).Append("\n");
            sb.Append("  ResendInterval: ").Append(ResendInterval).Append("\n");
            sb.Append("  ResendMaxAttempts: ").Append(ResendMaxAttempts).Append("\n");
            sb.Append("  ResendUrl: ").Append(ResendUrl).Append("\n");
            sb.Append("  Url: ").Append(Url).Append("\n");
            sb.Append("}\n");
            return sb.ToString();
        }

public override string ToString()
        {
            var sb = new StringBuilder();
            sb.Append("clreplaced Amount {\n");
            sb.Append("  Currency: ").Append(Currency).Append("\n");
            sb.Append("  Value: ").Append(Value).Append("\n");
            sb.Append("}\n");
            return sb.ToString();
        }

public override string ToString()
        {
            var sb = new StringBuilder();
            sb.Append("clreplaced Avs {\n");
            sb.Append("  AddressEditable: ").Append(AddressEditable).Append("\n");
            sb.Append("  Enabled: ").Append(Enabled).Append("\n");
            sb.Append("}\n");
            return sb.ToString();
        }

public override string ToString()
        {
            var sb = new StringBuilder();
            sb.Append("clreplaced CheckoutBalanceCheckResponse {\n");
            sb.Append("  AdditionalData: ").Append(AdditionalData.ToCollectionsString()).Append("\n");
            sb.Append("  Balance: ").Append(Balance).Append("\n");
            sb.Append("  FraudResult: ").Append(FraudResult).Append("\n");
            sb.Append("  PspReference: ").Append(PspReference).Append("\n");
            sb.Append("  RefusalReason: ").Append(RefusalReason).Append("\n");
            sb.Append("  ResultCode: ").Append(ResultCode).Append("\n");
            sb.Append("  TransactionLimit: ").Append(TransactionLimit).Append("\n");
            sb.Append("}\n");
            return sb.ToString();
        }

public override string ToString()
        {
            var sb = new StringBuilder();
            sb.Append("clreplaced InputDetail {\n");
            sb.Append("  Configuration: ").Append(Configuration.ToCollectionsString()).Append("\n");
            sb.Append("  Details: ").Append(Details.ObjectListToString()).Append("\n");
            sb.Append("  InputDetails: ").Append(InputDetails.ObjectListToString()).Append("\n");
            sb.Append("  ItemSearchUrl: ").Append(ItemSearchUrl).Append("\n");
            sb.Append("  Items: ").Append(Items.ObjectListToString()).Append("\n");
            sb.Append("  Key: ").Append(Key).Append("\n");
            sb.Append("  Optional: ").Append(Optional).Append("\n");
            sb.Append("  Type: ").Append(Type).Append("\n");
            sb.Append("  Value: ").Append(Value).Append("\n");
            sb.Append("}\n");
            return sb.ToString();
        }

public override string ToString()
        {
            var sb = new StringBuilder();
            sb.Append("clreplaced Installments2 {\n");
            sb.Append("  MaxNumberOfInstallments: ").Append(MaxNumberOfInstallments).Append("\n");
            sb.Append("}\n");
            return sb.ToString();
        }

public override string ToString()
        {
            var sb = new StringBuilder();
            sb.Append("clreplaced MerchantRiskIndicator {\n");
            sb.Append("  AddressMatch: ").Append(AddressMatch).Append("\n");
            sb.Append("  DeliveryAddressIndicator: ").Append(DeliveryAddressIndicator).Append("\n");
            sb.Append("  DeliveryEmail: ").Append(DeliveryEmail).Append("\n");
            sb.Append("  DeliveryTimeframe: ").Append(DeliveryTimeframe).Append("\n");
            sb.Append("  GiftCardAmount: ").Append(GiftCardAmount).Append("\n");
            sb.Append("  GiftCardCount: ").Append(GiftCardCount).Append("\n");
            sb.Append("  PreOrderDate: ").Append(PreOrderDate).Append("\n");
            sb.Append("  PreOrderPurchase: ").Append(PreOrderPurchase).Append("\n");
            sb.Append("  ReorderItems: ").Append(ReorderItems).Append("\n");
            sb.Append("}\n");
            return sb.ToString();
        }

public override string ToString()
        {
            var sb = new StringBuilder();
            sb.Append("clreplaced PaymentDetailsResponse {\n");
            sb.Append("  AdditionalData: ").Append(AdditionalData.ToCollectionsString()).Append("\n");
            sb.Append("  Amount: ").Append(Amount).Append("\n");
            sb.Append("  DonationToken: ").Append(DonationToken).Append("\n");
            sb.Append("  FraudResult: ").Append(FraudResult).Append("\n");
            sb.Append("  MerchantReference: ").Append(MerchantReference).Append("\n");
            sb.Append("  Order: ").Append(Order).Append("\n");
            sb.Append("  PaymentMethod: ").Append(PaymentMethod).Append("\n");
            sb.Append("  PspReference: ").Append(PspReference).Append("\n");
            sb.Append("  RefusalReason: ").Append(RefusalReason).Append("\n");
            sb.Append("  RefusalReasonCode: ").Append(RefusalReasonCode).Append("\n");
            sb.Append("  ResultCode: ").Append(ResultCode).Append("\n");
            sb.Append("  ShopperLocale: ").Append(ShopperLocale).Append("\n");
            sb.Append("  ThreeDS2Result: ").Append(ThreeDS2Result).Append("\n");
            sb.Append("}\n");
            return sb.ToString();
        }

public override string ToString()
        {
            var sb = new StringBuilder();
            sb.Append("clreplaced DeviceRenderOptions {\n");
            sb.Append("  SdkInterface: ").Append(SdkInterface).Append("\n");
            sb.Append("  SdkUiType: ").Append(SdkUiType.ObjectListToString()).Append("\n");
            sb.Append("}\n");
            return sb.ToString();
        }

public override string ToString()
        {
            var sb = new StringBuilder();
            sb.Append("clreplaced FraudCheckResult {\n");
            sb.Append("  AccountScore: ").Append(AccountScore).Append("\n");
            sb.Append("  CheckId: ").Append(CheckId).Append("\n");
            sb.Append("  Name: ").Append(Name).Append("\n");
            sb.Append("}\n");
            return sb.ToString();
        }

public override string ToString()
        {
            var sb = new StringBuilder();
            sb.Append("clreplaced InstallmentOption {\n");
            sb.Append("  MaxValue: ").Append(MaxValue).Append("\n");
            sb.Append("  Plans: ").Append(Plans.ObjectListToString()).Append("\n");
            sb.Append("}\n");
            return sb.ToString();
        }

public override string ToString()
        {
            var sb = new StringBuilder();
            sb.Append("clreplaced Name {\n");
            sb.Append("  FirstName: ").Append(FirstName).Append("\n");
            sb.Append("  Gender: ").Append(Gender).Append("\n");
            sb.Append("  Infix: ").Append(Infix).Append("\n");
            sb.Append("  LastName: ").Append(LastName).Append("\n");
            sb.Append("}\n");
            return sb.ToString();
        }

public override string ToString()
        {
            var sb = new StringBuilder();
            sb.Append("clreplaced PaymentMethodsRequest {\n");
            sb.Append("  AdditionalData: ").Append(AdditionalData.ToCollectionsString()).Append("\n");
            sb.Append("  AllowedPaymentMethods: ").Append(AllowedPaymentMethods.ToListString()).Append("\n");
            sb.Append("  Amount: ").Append(Amount).Append("\n");
            sb.Append("  BlockedPaymentMethods: ").Append(BlockedPaymentMethods.ToListString()).Append("\n");
            sb.Append("  Channel: ").Append(Channel).Append("\n");
            sb.Append("  CountryCode: ").Append(CountryCode).Append("\n");
            sb.Append("  MerchantAccount: ").Append(MerchantAccount).Append("\n");
            sb.Append("  Order: ").Append(Order).Append("\n");
            sb.Append("  ShopperLocale: ").Append(ShopperLocale).Append("\n");
            sb.Append("  ShopperReference: ").Append(ShopperReference).Append("\n");
            sb.Append("  SplitCardFundingSources: ").Append(SplitCardFundingSources).Append("\n");
            sb.Append("  Store: ").Append(Store).Append("\n");
            sb.Append("}\n");
            return sb.ToString();
        }