// interpolationFuncTitle implements the "title" function that returns a copy of the
// string in which first characters of all the words are capitalized.
171636
func interpolationFuncTitle() ast.Function {
	return ast.Function{
		ArgTypes:   []ast.Type{ast.TypeString},
		ReturnType: ast.TypeString,
		Callback: func(args []interface{}) (interface{}, error) {
			toTitle := args[0].(string)
			return strings.Title(toTitle), nil
		},
	}
}
681963
func (s *ComplianceItemEntry) SetTitle(v string) *ComplianceItemEntry {
	s.Title = &v
	return s
}
805614
func (c *CheckRunOutput) GetTitle() string {
	if c == nil || c.Title == nil {
		return ""
	}
	return *c.Title
}
352766
func NormalizeURITitle(URI string) string {
	s := strings.Title(doNormalizeURI(URI))
	return strings.Replace(s, " ", "", -1)

}
868716
func (m *Milestone) GetTitle() string {
	if m == nil || m.Title == nil {
		return ""
	}
	return *m.Title
}
910807
func Title(gender int) string {
	var title = ""
	switch gender {
	case Male:
		title = randomFrom(jsonData.MaleTitles)
		break
	case Female:
		title = randomFrom(jsonData.FemaleTitles)
		break
	default:
		title = FirstName(privateRand.Intn(2))
		break
	}
	return title
}
723446
func interpolationFuncLower() ast.Function {
	return ast.Function{
		ArgTypes:   []ast.Type{ast.TypeString},
		ReturnType: ast.TypeString,
		Callback: func(args []interface{}) (interface{}, error) {
			toLower := args[0].(string)
			return strings.ToLower(toLower), nil
		},
	}
}
969826
func interpolationFuncJSONEncode() ast.Function {
	return ast.Function{
		ArgTypes:   []ast.Type{ast.TypeAny},
		ReturnType: ast.TypeString,
		Callback: func(args []interface{}) (interface{}, error) {
			var toEncode interface{}

			switch typedArg := args[0].(type) {
			case string:
				toEncode = typedArg

			case []ast.Variable:
				strings := make([]string, len(typedArg))

				for i, v := range typedArg {
					if v.Type != ast.TypeString {
						variable, _ := hil.InterfaceToVariable(typedArg)
						toEncode, _ = hil.VariableToInterface(variable)

						jEnc, err := json.Marshal(toEncode)
						if err != nil {
							return "", fmt.Errorf("failed to encode JSON data '%s'", toEncode)
						}
						return string(jEnc), nil

					}
					strings[i] = v.Value.(string)
				}
				toEncode = strings

			case map[string]ast.Variable:
				stringMap := make(map[string]string)
				for k, v := range typedArg {
					if v.Type != ast.TypeString {
						variable, _ := hil.InterfaceToVariable(typedArg)
						toEncode, _ = hil.VariableToInterface(variable)

						jEnc, err := json.Marshal(toEncode)
						if err != nil {
							return "", fmt.Errorf("failed to encode JSON data '%s'", toEncode)
						}
						return string(jEnc), nil
					}
					stringMap[k] = v.Value.(string)
				}
				toEncode = stringMap

			default:
				return "", fmt.Errorf("unknown type for JSON encoding: %T", args[0])
			}

			jEnc, err := json.Marshal(toEncode)
			if err != nil {
				return "", fmt.Errorf("failed to encode JSON data '%s'", toEncode)
			}
			return string(jEnc), nil
		},
	}
}
1332425
func Title(val string) {
	if a, ok := apiDefinition(); ok {
		a.Title = val
	}
}
468238
func interpolationFuncRsaDecrypt() ast.Function {
	return ast.Function{
		ArgTypes:   []ast.Type{ast.TypeString, ast.TypeString},
		ReturnType: ast.TypeString,
		Callback: func(args []interface{}) (interface{}, error) {
			s := args[0].(string)
			key := args[1].(string)

			b, err := base64.StdEncoding.DecodeString(s)
			if err != nil {
				return "", fmt.Errorf("Failed to decode input %q: cipher text must be base64-encoded", s)
			}

			block, _ := pem.Decode([]byte(key))
			if block == nil {
				return "", fmt.Errorf("Failed to read key %q: no key found", key)
			}
			if block.Headers["Proc-Type"] == "4,ENCRYPTED" {
				return "", fmt.Errorf(
					"Failed to read key %q: password protected keys are\n"+
						"not supported. Please decrypt the key prior to use.", key)
			}

			x509Key, err := x509.ParsePKCS1PrivateKey(block.Bytes)
			if err != nil {
				return "", err
			}

			out, err := rsa.DecryptPKCS1v15(nil, x509Key, b)
			if err != nil {
				return "", err
			}

			return string(out), nil
		},
	}
}
670650
func (s *PullRequest) SetTitle(v string) *PullRequest {
	s.Title = &v
	return s
}
170361
func (n *NewPullRequest) GetTitle() string {
	if n == nil || n.Title == nil {
		return ""
	}
	return *n.Title
}
865300
func (f *DataFuncs) ToJSONPretty(indent string, in interface{}) (string, error) {
	return data.ToJSONPretty(indent, in)
}
1338945
func (s *AwsSecurityFindingFilters) SetTitle(v []*StringFilter) *AwsSecurityFindingFilters {
	s.Title = v
	return s
}
821233
func (p *MainPage) Title() string {
	
	qb422016 := qt422016.AcquireByteBuffer()
	
	p.WriteTitle(qb422016)
	
	qs422016 := string(qb422016.B)
	
	qt422016.ReleaseByteBuffer(qb422016)
	
	return qs422016

}
792477
func (s *CreatePullRequestInput) SetTitle(v string) *CreatePullRequestInput {
	s.Title = &v
	return s
}
736938
func (p *PullRequest) GetTitle() string {
	if p == nil || p.Title == nil {
		return ""
	}
	return *p.Title
}