types.go

// This file was auto-generated by Fern from our API Definition.

package api

import (
	json "encoding/json"
	fmt "fmt"

	internal "github.com/StackGuardian/sg-sdk-go/internal"
)

// * `apply` - apply
// * `destroy` - destroy
// * `plan` - plan
// * `plan-destroy` - plan-destroy
// * `plan-without-policy` - plan-without-policy
// * `refresh` - refresh
type ActionEnum string

const (
	ActionEnumApply             ActionEnum = "apply"
	ActionEnumDestroy           ActionEnum = "destroy"
	ActionEnumPlan              ActionEnum = "plan"
	ActionEnumPlanDestroy       ActionEnum = "plan-destroy"
	ActionEnumPlanWithoutPolicy ActionEnum = "plan-without-policy"
	ActionEnumRefresh           ActionEnum = "refresh"
)

func NewActionEnumFromString(s string) (ActionEnum, error) {
	switch s {
	case "apply":
		return ActionEnumApply, nil
	case "destroy":
		return ActionEnumDestroy, nil
	case "plan":
		return ActionEnumPlan, nil
	case "plan-destroy":
		return ActionEnumPlanDestroy, nil
	case "plan-without-policy":
		return ActionEnumPlanWithoutPolicy, nil
	case "refresh":
		return ActionEnumRefresh, nil
	}
	var t ActionEnum
	return "", fmt.Errorf("%s is not a valid %T", s, t)
}

func (a ActionEnum) Ptr() *ActionEnum {
	return &a
}

type Actions struct {
	Name        string                 `json:"name" url:"name"`
	Description *string                `json:"description,omitempty" url:"description,omitempty"`
	Default     *bool                  `json:"default,omitempty" url:"default,omitempty"`
	Order       map[string]interface{} `json:"order,omitempty" url:"order,omitempty"`

	extraProperties map[string]interface{}
	rawJSON         json.RawMessage
}

func (a *Actions) GetName() string {
	if a == nil {
		return ""
	}
	return a.Name
}

func (a *Actions) GetDescription() *string {
	if a == nil {
		return nil
	}
	return a.Description
}

func (a *Actions) GetDefault() *bool {
	if a == nil {
		return nil
	}
	return a.Default
}

func (a *Actions) GetOrder() map[string]interface{} {
	if a == nil {
		return nil
	}
	return a.Order
}

func (a *Actions) GetExtraProperties() map[string]interface{} {
	return a.extraProperties
}

func (a *Actions) UnmarshalJSON(data []byte) error {
	type unmarshaler Actions
	var value unmarshaler
	if err := json.Unmarshal(data, &value); err != nil {
		return err
	}
	*a = Actions(value)
	extraProperties, err := internal.ExtractExtraProperties(data, *a)
	if err != nil {
		return err
	}
	a.extraProperties = extraProperties
	a.rawJSON = json.RawMessage(data)
	return nil
}

func (a *Actions) String() string {
	if len(a.rawJSON) > 0 {
		if value, err := internal.StringifyJSON(a.rawJSON); err == nil {
			return value
		}
	}
	if value, err := internal.StringifyJSON(a); err == nil {
		return value
	}
	return fmt.Sprintf("%#v", a)
}

type CacheConfig struct {
	Enabled      bool       `json:"enabled" url:"enabled"`
	FallbackKeys []string   `json:"fallback_keys,omitempty" url:"fallback_keys,omitempty"`
	Paths        []string   `json:"paths,omitempty" url:"paths,omitempty"`
	Key          string     `json:"key" url:"key"`
	Policy       PolicyEnum `json:"policy" url:"policy"`

	extraProperties map[string]interface{}
	rawJSON         json.RawMessage
}

func (c *CacheConfig) GetEnabled() bool {
	if c == nil {
		return false
	}
	return c.Enabled
}

func (c *CacheConfig) GetFallbackKeys() []string {
	if c == nil {
		return nil
	}
	return c.FallbackKeys
}

func (c *CacheConfig) GetPaths() []string {
	if c == nil {
		return nil
	}
	return c.Paths
}

func (c *CacheConfig) GetKey() string {
	if c == nil {
		return ""
	}
	return c.Key
}

func (c *CacheConfig) GetPolicy() PolicyEnum {
	if c == nil {
		return ""
	}
	return c.Policy
}

func (c *CacheConfig) GetExtraProperties() map[string]interface{} {
	return c.extraProperties
}

func (c *CacheConfig) UnmarshalJSON(data []byte) error {
	type unmarshaler CacheConfig
	var value unmarshaler
	if err := json.Unmarshal(data, &value); err != nil {
		return err
	}
	*c = CacheConfig(value)
	extraProperties, err := internal.ExtractExtraProperties(data, *c)
	if err != nil {
		return err
	}
	c.extraProperties = extraProperties
	c.rawJSON = json.RawMessage(data)
	return nil
}

func (c *CacheConfig) String() string {
	if len(c.rawJSON) > 0 {
		if value, err := internal.StringifyJSON(c.rawJSON); err == nil {
			return value
		}
	}
	if value, err := internal.StringifyJSON(c); err == nil {
		return value
	}
	return fmt.Sprintf("%#v", c)
}

type CustomSource struct {
	SourceConfigDestKind CustomSourceSourceConfigDestKindEnum `json:"sourceConfigDestKind" url:"sourceConfigDestKind"`
	Config               *CustomSourceConfig                  `json:"config,omitempty" url:"config,omitempty"`
	AdditionalConfig     map[string]interface{}               `json:"additionalConfig,omitempty" url:"additionalConfig,omitempty"`

	extraProperties map[string]interface{}
	rawJSON         json.RawMessage
}

func (c *CustomSource) GetSourceConfigDestKind() CustomSourceSourceConfigDestKindEnum {
	if c == nil {
		return ""
	}
	return c.SourceConfigDestKind
}

func (c *CustomSource) GetConfig() *CustomSourceConfig {
	if c == nil {
		return nil
	}
	return c.Config
}

func (c *CustomSource) GetAdditionalConfig() map[string]interface{} {
	if c == nil {
		return nil
	}
	return c.AdditionalConfig
}

func (c *CustomSource) GetExtraProperties() map[string]interface{} {
	return c.extraProperties
}

func (c *CustomSource) UnmarshalJSON(data []byte) error {
	type unmarshaler CustomSource
	var value unmarshaler
	if err := json.Unmarshal(data, &value); err != nil {
		return err
	}
	*c = CustomSource(value)
	extraProperties, err := internal.ExtractExtraProperties(data, *c)
	if err != nil {
		return err
	}
	c.extraProperties = extraProperties
	c.rawJSON = json.RawMessage(data)
	return nil
}

func (c *CustomSource) String() string {
	if len(c.rawJSON) > 0 {
		if value, err := internal.StringifyJSON(c.rawJSON); err == nil {
			return value
		}
	}
	if value, err := internal.StringifyJSON(c); err == nil {
		return value
	}
	return fmt.Sprintf("%#v", c)
}

type CustomSourceConfig struct {
	IsPrivate               *bool   `json:"isPrivate,omitempty" url:"isPrivate,omitempty"`
	Auth                    *string `json:"auth,omitempty" url:"auth,omitempty"`
	WorkingDir              *string `json:"workingDir,omitempty" url:"workingDir,omitempty"`
	GitSparseCheckoutConfig *string `json:"gitSparseCheckoutConfig,omitempty" url:"gitSparseCheckoutConfig,omitempty"`
	GitCoreAutoCrlf         *bool   `json:"gitCoreAutoCRLF,omitempty" url:"gitCoreAutoCRLF,omitempty"`
	Ref                     *string `json:"ref,omitempty" url:"ref,omitempty"`
	Repo                    *string `json:"repo,omitempty" url:"repo,omitempty"`
	IncludeSubModule        *bool   `json:"includeSubModule,omitempty" url:"includeSubModule,omitempty"`

	extraProperties map[string]interface{}
	rawJSON         json.RawMessage
}

func (c *CustomSourceConfig) GetIsPrivate() *bool {
	if c == nil {
		return nil
	}
	return c.IsPrivate
}

func (c *CustomSourceConfig) GetAuth() *string {
	if c == nil {
		return nil
	}
	return c.Auth
}

func (c *CustomSourceConfig) GetWorkingDir() *string {
	if c == nil {
		return nil
	}
	return c.WorkingDir
}

func (c *CustomSourceConfig) GetGitSparseCheckoutConfig() *string {
	if c == nil {
		return nil
	}
	return c.GitSparseCheckoutConfig
}

func (c *CustomSourceConfig) GetGitCoreAutoCrlf() *bool {
	if c == nil {
		return nil
	}
	return c.GitCoreAutoCrlf
}

func (c *CustomSourceConfig) GetRef() *string {
	if c == nil {
		return nil
	}
	return c.Ref
}

func (c *CustomSourceConfig) GetRepo() *string {
	if c == nil {
		return nil
	}
	return c.Repo
}

func (c *CustomSourceConfig) GetIncludeSubModule() *bool {
	if c == nil {
		return nil
	}
	return c.IncludeSubModule
}

func (c *CustomSourceConfig) GetExtraProperties() map[string]interface{} {
	return c.extraProperties
}

func (c *CustomSourceConfig) UnmarshalJSON(data []byte) error {
	type unmarshaler CustomSourceConfig
	var value unmarshaler
	if err := json.Unmarshal(data, &value); err != nil {
		return err
	}
	*c = CustomSourceConfig(value)
	extraProperties, err := internal.ExtractExtraProperties(data, *c)
	if err != nil {
		return err
	}
	c.extraProperties = extraProperties
	c.rawJSON = json.RawMessage(data)
	return nil
}

func (c *CustomSourceConfig) String() string {
	if len(c.rawJSON) > 0 {
		if value, err := internal.StringifyJSON(c.rawJSON); err == nil {
			return value
		}
	}
	if value, err := internal.StringifyJSON(c); err == nil {
		return value
	}
	return fmt.Sprintf("%#v", c)
}

// * `GITHUB_COM` - GITHUB_COM
// * `GITHUB_APP_CUSTOM` - GITHUB_APP_CUSTOM
// * `GIT_OTHER` - GIT_OTHER
// * `BITBUCKET_ORG` - BITBUCKET_ORG
// * `GITLAB_COM` - GITLAB_COM
// * `AZURE_DEVOPS` - AZURE_DEVOPS
type CustomSourceSourceConfigDestKindEnum string

const (
	CustomSourceSourceConfigDestKindEnumGithubCom       CustomSourceSourceConfigDestKindEnum = "GITHUB_COM"
	CustomSourceSourceConfigDestKindEnumGithubAppCustom CustomSourceSourceConfigDestKindEnum = "GITHUB_APP_CUSTOM"
	CustomSourceSourceConfigDestKindEnumGitOther        CustomSourceSourceConfigDestKindEnum = "GIT_OTHER"
	CustomSourceSourceConfigDestKindEnumBitbucketOrg    CustomSourceSourceConfigDestKindEnum = "BITBUCKET_ORG"
	CustomSourceSourceConfigDestKindEnumGitlabCom       CustomSourceSourceConfigDestKindEnum = "GITLAB_COM"
	CustomSourceSourceConfigDestKindEnumAzureDevops     CustomSourceSourceConfigDestKindEnum = "AZURE_DEVOPS"
)

func NewCustomSourceSourceConfigDestKindEnumFromString(s string) (CustomSourceSourceConfigDestKindEnum, error) {
	switch s {
	case "GITHUB_COM":
		return CustomSourceSourceConfigDestKindEnumGithubCom, nil
	case "GITHUB_APP_CUSTOM":
		return CustomSourceSourceConfigDestKindEnumGithubAppCustom, nil
	case "GIT_OTHER":
		return CustomSourceSourceConfigDestKindEnumGitOther, nil
	case "BITBUCKET_ORG":
		return CustomSourceSourceConfigDestKindEnumBitbucketOrg, nil
	case "GITLAB_COM":
		return CustomSourceSourceConfigDestKindEnumGitlabCom, nil
	case "AZURE_DEVOPS":
		return CustomSourceSourceConfigDestKindEnumAzureDevops, nil
	}
	var t CustomSourceSourceConfigDestKindEnum
	return "", fmt.Errorf("%s is not a valid %T", s, t)
}

func (c CustomSourceSourceConfigDestKindEnum) Ptr() *CustomSourceSourceConfigDestKindEnum {
	return &c
}

type DeploymentPlatformConfig struct {
	Kind   DeploymentPlatformConfigKindEnum `json:"kind" url:"kind"`
	Config map[string]interface{}           `json:"config,omitempty" url:"config,omitempty"`

	extraProperties map[string]interface{}
	rawJSON         json.RawMessage
}

func (d *DeploymentPlatformConfig) GetKind() DeploymentPlatformConfigKindEnum {
	if d == nil {
		return ""
	}
	return d.Kind
}

func (d *DeploymentPlatformConfig) GetConfig() map[string]interface{} {
	if d == nil {
		return nil
	}
	return d.Config
}

func (d *DeploymentPlatformConfig) GetExtraProperties() map[string]interface{} {
	return d.extraProperties
}

func (d *DeploymentPlatformConfig) UnmarshalJSON(data []byte) error {
	type unmarshaler DeploymentPlatformConfig
	var value unmarshaler
	if err := json.Unmarshal(data, &value); err != nil {
		return err
	}
	*d = DeploymentPlatformConfig(value)
	extraProperties, err := internal.ExtractExtraProperties(data, *d)
	if err != nil {
		return err
	}
	d.extraProperties = extraProperties
	d.rawJSON = json.RawMessage(data)
	return nil
}

func (d *DeploymentPlatformConfig) String() string {
	if len(d.rawJSON) > 0 {
		if value, err := internal.StringifyJSON(d.rawJSON); err == nil {
			return value
		}
	}
	if value, err := internal.StringifyJSON(d); err == nil {
		return value
	}
	return fmt.Sprintf("%#v", d)
}

// * `AWS_STATIC` - AWS_STATIC
// * `AWS_RBAC` - AWS_RBAC
// * `AWS_OIDC` - AWS_OIDC
// * `AZURE_STATIC` - AZURE_STATIC
// * `AZURE_OIDC` - AZURE_OIDC
// * `GCP_STATIC` - GCP_STATIC
// * `GCP_OIDC` - GCP_OIDC
type DeploymentPlatformConfigKindEnum string

const (
	DeploymentPlatformConfigKindEnumAwsStatic   DeploymentPlatformConfigKindEnum = "AWS_STATIC"
	DeploymentPlatformConfigKindEnumAwsRbac     DeploymentPlatformConfigKindEnum = "AWS_RBAC"
	DeploymentPlatformConfigKindEnumAwsOidc     DeploymentPlatformConfigKindEnum = "AWS_OIDC"
	DeploymentPlatformConfigKindEnumAzureStatic DeploymentPlatformConfigKindEnum = "AZURE_STATIC"
	DeploymentPlatformConfigKindEnumAzureOidc   DeploymentPlatformConfigKindEnum = "AZURE_OIDC"
	DeploymentPlatformConfigKindEnumGcpStatic   DeploymentPlatformConfigKindEnum = "GCP_STATIC"
	DeploymentPlatformConfigKindEnumGcpOidc     DeploymentPlatformConfigKindEnum = "GCP_OIDC"
)

func NewDeploymentPlatformConfigKindEnumFromString(s string) (DeploymentPlatformConfigKindEnum, error) {
	switch s {
	case "AWS_STATIC":
		return DeploymentPlatformConfigKindEnumAwsStatic, nil
	case "AWS_RBAC":
		return DeploymentPlatformConfigKindEnumAwsRbac, nil
	case "AWS_OIDC":
		return DeploymentPlatformConfigKindEnumAwsOidc, nil
	case "AZURE_STATIC":
		return DeploymentPlatformConfigKindEnumAzureStatic, nil
	case "AZURE_OIDC":
		return DeploymentPlatformConfigKindEnumAzureOidc, nil
	case "GCP_STATIC":
		return DeploymentPlatformConfigKindEnumGcpStatic, nil
	case "GCP_OIDC":
		return DeploymentPlatformConfigKindEnumGcpOidc, nil
	}
	var t DeploymentPlatformConfigKindEnum
	return "", fmt.Errorf("%s is not a valid %T", s, t)
}

func (d DeploymentPlatformConfigKindEnum) Ptr() *DeploymentPlatformConfigKindEnum {
	return &d
}

type EnvVarConfig struct {
	VarName   string  `json:"varName" url:"varName"`
	TextValue *string `json:"textValue,omitempty" url:"textValue,omitempty"`
	SecretId  *string `json:"secretId,omitempty" url:"secretId,omitempty"`

	extraProperties map[string]interface{}
	rawJSON         json.RawMessage
}

func (e *EnvVarConfig) GetVarName() string {
	if e == nil {
		return ""
	}
	return e.VarName
}

func (e *EnvVarConfig) GetTextValue() *string {
	if e == nil {
		return nil
	}
	return e.TextValue
}

func (e *EnvVarConfig) GetSecretId() *string {
	if e == nil {
		return nil
	}
	return e.SecretId
}

func (e *EnvVarConfig) GetExtraProperties() map[string]interface{} {
	return e.extraProperties
}

func (e *EnvVarConfig) UnmarshalJSON(data []byte) error {
	type unmarshaler EnvVarConfig
	var value unmarshaler
	if err := json.Unmarshal(data, &value); err != nil {
		return err
	}
	*e = EnvVarConfig(value)
	extraProperties, err := internal.ExtractExtraProperties(data, *e)
	if err != nil {
		return err
	}
	e.extraProperties = extraProperties
	e.rawJSON = json.RawMessage(data)
	return nil
}

func (e *EnvVarConfig) String() string {
	if len(e.rawJSON) > 0 {
		if value, err := internal.StringifyJSON(e.rawJSON); err == nil {
			return value
		}
	}
	if value, err := internal.StringifyJSON(e); err == nil {
		return value
	}
	return fmt.Sprintf("%#v", e)
}

type EnvVars struct {
	Kind   EnvVarsKindEnum `json:"kind" url:"kind"`
	Config *EnvVarConfig   `json:"config,omitempty" url:"config,omitempty"`

	extraProperties map[string]interface{}
	rawJSON         json.RawMessage
}

func (e *EnvVars) GetKind() EnvVarsKindEnum {
	if e == nil {
		return ""
	}
	return e.Kind
}

func (e *EnvVars) GetConfig() *EnvVarConfig {
	if e == nil {
		return nil
	}
	return e.Config
}

func (e *EnvVars) GetExtraProperties() map[string]interface{} {
	return e.extraProperties
}

func (e *EnvVars) UnmarshalJSON(data []byte) error {
	type unmarshaler EnvVars
	var value unmarshaler
	if err := json.Unmarshal(data, &value); err != nil {
		return err
	}
	*e = EnvVars(value)
	extraProperties, err := internal.ExtractExtraProperties(data, *e)
	if err != nil {
		return err
	}
	e.extraProperties = extraProperties
	e.rawJSON = json.RawMessage(data)
	return nil
}

func (e *EnvVars) String() string {
	if len(e.rawJSON) > 0 {
		if value, err := internal.StringifyJSON(e.rawJSON); err == nil {
			return value
		}
	}
	if value, err := internal.StringifyJSON(e); err == nil {
		return value
	}
	return fmt.Sprintf("%#v", e)
}

// * `PLAIN_TEXT` - PLAIN_TEXT
// * `VAULT_SECRET` - VAULT_SECRET
type EnvVarsKindEnum string

const (
	EnvVarsKindEnumPlainText   EnvVarsKindEnum = "PLAIN_TEXT"
	EnvVarsKindEnumVaultSecret EnvVarsKindEnum = "VAULT_SECRET"
)

func NewEnvVarsKindEnumFromString(s string) (EnvVarsKindEnum, error) {
	switch s {
	case "PLAIN_TEXT":
		return EnvVarsKindEnumPlainText, nil
	case "VAULT_SECRET":
		return EnvVarsKindEnumVaultSecret, nil
	}
	var t EnvVarsKindEnum
	return "", fmt.Errorf("%s is not a valid %T", s, t)
}

func (e EnvVarsKindEnum) Ptr() *EnvVarsKindEnum {
	return &e
}

type GeneratedMsgDeploymentplatformconfig struct {
	Kind   string                                      `json:"kind" url:"kind"`
	Config *GeneratedMsgDeploymentplatformconfigConfig `json:"config,omitempty" url:"config,omitempty"`

	extraProperties map[string]interface{}
	rawJSON         json.RawMessage
}

func (g *GeneratedMsgDeploymentplatformconfig) GetKind() string {
	if g == nil {
		return ""
	}
	return g.Kind
}

func (g *GeneratedMsgDeploymentplatformconfig) GetConfig() *GeneratedMsgDeploymentplatformconfigConfig {
	if g == nil {
		return nil
	}
	return g.Config
}

func (g *GeneratedMsgDeploymentplatformconfig) GetExtraProperties() map[string]interface{} {
	return g.extraProperties
}

func (g *GeneratedMsgDeploymentplatformconfig) UnmarshalJSON(data []byte) error {
	type unmarshaler GeneratedMsgDeploymentplatformconfig
	var value unmarshaler
	if err := json.Unmarshal(data, &value); err != nil {
		return err
	}
	*g = GeneratedMsgDeploymentplatformconfig(value)
	extraProperties, err := internal.ExtractExtraProperties(data, *g)
	if err != nil {
		return err
	}
	g.extraProperties = extraProperties
	g.rawJSON = json.RawMessage(data)
	return nil
}

func (g *GeneratedMsgDeploymentplatformconfig) String() string {
	if len(g.rawJSON) > 0 {
		if value, err := internal.StringifyJSON(g.rawJSON); err == nil {
			return value
		}
	}
	if value, err := internal.StringifyJSON(g); err == nil {
		return value
	}
	return fmt.Sprintf("%#v", g)
}

type GeneratedMsgDeploymentplatformconfigConfig struct {
	ProfileName   string                 `json:"profileName" url:"profileName"`
	IntegrationId string                 `json:"integrationId" url:"integrationId"`
	MiniSteps     *GeneratedMsgMinisteps `json:"MiniSteps,omitempty" url:"MiniSteps,omitempty"`

	extraProperties map[string]interface{}
	rawJSON         json.RawMessage
}

func (g *GeneratedMsgDeploymentplatformconfigConfig) GetProfileName() string {
	if g == nil {
		return ""
	}
	return g.ProfileName
}

func (g *GeneratedMsgDeploymentplatformconfigConfig) GetIntegrationId() string {
	if g == nil {
		return ""
	}
	return g.IntegrationId
}

func (g *GeneratedMsgDeploymentplatformconfigConfig) GetMiniSteps() *GeneratedMsgMinisteps {
	if g == nil {
		return nil
	}
	return g.MiniSteps
}

func (g *GeneratedMsgDeploymentplatformconfigConfig) GetExtraProperties() map[string]interface{} {
	return g.extraProperties
}

func (g *GeneratedMsgDeploymentplatformconfigConfig) UnmarshalJSON(data []byte) error {
	type unmarshaler GeneratedMsgDeploymentplatformconfigConfig
	var value unmarshaler
	if err := json.Unmarshal(data, &value); err != nil {
		return err
	}
	*g = GeneratedMsgDeploymentplatformconfigConfig(value)
	extraProperties, err := internal.ExtractExtraProperties(data, *g)
	if err != nil {
		return err
	}
	g.extraProperties = extraProperties
	g.rawJSON = json.RawMessage(data)
	return nil
}

func (g *GeneratedMsgDeploymentplatformconfigConfig) String() string {
	if len(g.rawJSON) > 0 {
		if value, err := internal.StringifyJSON(g.rawJSON); err == nil {
			return value
		}
	}
	if value, err := internal.StringifyJSON(g); err == nil {
		return value
	}
	return fmt.Sprintf("%#v", g)
}

type GeneratedMsgEnvironmentvariables struct {
	Kind   string                                  `json:"kind" url:"kind"`
	Config *GeneratedMsgEnvironmentvariablesConfig `json:"config,omitempty" url:"config,omitempty"`

	extraProperties map[string]interface{}
	rawJSON         json.RawMessage
}

func (g *GeneratedMsgEnvironmentvariables) GetKind() string {
	if g == nil {
		return ""
	}
	return g.Kind
}

func (g *GeneratedMsgEnvironmentvariables) GetConfig() *GeneratedMsgEnvironmentvariablesConfig {
	if g == nil {
		return nil
	}
	return g.Config
}

func (g *GeneratedMsgEnvironmentvariables) GetExtraProperties() map[string]interface{} {
	return g.extraProperties
}

func (g *GeneratedMsgEnvironmentvariables) UnmarshalJSON(data []byte) error {
	type unmarshaler GeneratedMsgEnvironmentvariables
	var value unmarshaler
	if err := json.Unmarshal(data, &value); err != nil {
		return err
	}
	*g = GeneratedMsgEnvironmentvariables(value)
	extraProperties, err := internal.ExtractExtraProperties(data, *g)
	if err != nil {
		return err
	}
	g.extraProperties = extraProperties
	g.rawJSON = json.RawMessage(data)
	return nil
}

func (g *GeneratedMsgEnvironmentvariables) String() string {
	if len(g.rawJSON) > 0 {
		if value, err := internal.StringifyJSON(g.rawJSON); err == nil {
			return value
		}
	}
	if value, err := internal.StringifyJSON(g); err == nil {
		return value
	}
	return fmt.Sprintf("%#v", g)
}

type GeneratedMsgEnvironmentvariablesConfig struct {
	TextValue string                 `json:"textValue" url:"textValue"`
	VarName   string                 `json:"varName" url:"varName"`
	VcsConfig *GeneratedMsgVcsconfig `json:"VCSConfig,omitempty" url:"VCSConfig,omitempty"`

	extraProperties map[string]interface{}
	rawJSON         json.RawMessage
}

func (g *GeneratedMsgEnvironmentvariablesConfig) GetTextValue() string {
	if g == nil {
		return ""
	}
	return g.TextValue
}

func (g *GeneratedMsgEnvironmentvariablesConfig) GetVarName() string {
	if g == nil {
		return ""
	}
	return g.VarName
}

func (g *GeneratedMsgEnvironmentvariablesConfig) GetVcsConfig() *GeneratedMsgVcsconfig {
	if g == nil {
		return nil
	}
	return g.VcsConfig
}

func (g *GeneratedMsgEnvironmentvariablesConfig) GetExtraProperties() map[string]interface{} {
	return g.extraProperties
}

func (g *GeneratedMsgEnvironmentvariablesConfig) UnmarshalJSON(data []byte) error {
	type unmarshaler GeneratedMsgEnvironmentvariablesConfig
	var value unmarshaler
	if err := json.Unmarshal(data, &value); err != nil {
		return err
	}
	*g = GeneratedMsgEnvironmentvariablesConfig(value)
	extraProperties, err := internal.ExtractExtraProperties(data, *g)
	if err != nil {
		return err
	}
	g.extraProperties = extraProperties
	g.rawJSON = json.RawMessage(data)
	return nil
}

func (g *GeneratedMsgEnvironmentvariablesConfig) String() string {
	if len(g.rawJSON) > 0 {
		if value, err := internal.StringifyJSON(g.rawJSON); err == nil {
			return value
		}
	}
	if value, err := internal.StringifyJSON(g); err == nil {
		return value
	}
	return fmt.Sprintf("%#v", g)
}

type GeneratedMsgMinisteps struct {
	Webhooks *GeneratedMsgMinistepsWebhooks `json:"webhooks,omitempty" url:"webhooks,omitempty"`

	extraProperties map[string]interface{}
	rawJSON         json.RawMessage
}

func (g *GeneratedMsgMinisteps) GetWebhooks() *GeneratedMsgMinistepsWebhooks {
	if g == nil {
		return nil
	}
	return g.Webhooks
}

func (g *GeneratedMsgMinisteps) GetExtraProperties() map[string]interface{} {
	return g.extraProperties
}

func (g *GeneratedMsgMinisteps) UnmarshalJSON(data []byte) error {
	type unmarshaler GeneratedMsgMinisteps
	var value unmarshaler
	if err := json.Unmarshal(data, &value); err != nil {
		return err
	}
	*g = GeneratedMsgMinisteps(value)
	extraProperties, err := internal.ExtractExtraProperties(data, *g)
	if err != nil {
		return err
	}
	g.extraProperties = extraProperties
	g.rawJSON = json.RawMessage(data)
	return nil
}

func (g *GeneratedMsgMinisteps) String() string {
	if len(g.rawJSON) > 0 {
		if value, err := internal.StringifyJSON(g.rawJSON); err == nil {
			return value
		}
	}
	if value, err := internal.StringifyJSON(g); err == nil {
		return value
	}
	return fmt.Sprintf("%#v", g)
}

type GeneratedMsgMinistepsNotifications struct {
	Email *GeneratedMsgMinistepsNotificationsEmail `json:"email,omitempty" url:"email,omitempty"`

	extraProperties map[string]interface{}
	rawJSON         json.RawMessage
}

func (g *GeneratedMsgMinistepsNotifications) GetEmail() *GeneratedMsgMinistepsNotificationsEmail {
	if g == nil {
		return nil
	}
	return g.Email
}

func (g *GeneratedMsgMinistepsNotifications) GetExtraProperties() map[string]interface{} {
	return g.extraProperties
}

func (g *GeneratedMsgMinistepsNotifications) UnmarshalJSON(data []byte) error {
	type unmarshaler GeneratedMsgMinistepsNotifications
	var value unmarshaler
	if err := json.Unmarshal(data, &value); err != nil {
		return err
	}
	*g = GeneratedMsgMinistepsNotifications(value)
	extraProperties, err := internal.ExtractExtraProperties(data, *g)
	if err != nil {
		return err
	}
	g.extraProperties = extraProperties
	g.rawJSON = json.RawMessage(data)
	return nil
}

func (g *GeneratedMsgMinistepsNotifications) String() string {
	if len(g.rawJSON) > 0 {
		if value, err := internal.StringifyJSON(g.rawJSON); err == nil {
			return value
		}
	}
	if value, err := internal.StringifyJSON(g); err == nil {
		return value
	}
	return fmt.Sprintf("%#v", g)
}

type GeneratedMsgMinistepsNotificationsEmail struct {
	ApprovalRequired []interface{}                    `json:"APPROVAL_REQUIRED,omitempty" url:"APPROVAL_REQUIRED,omitempty"`
	Cancelled        []interface{}                    `json:"CANCELLED,omitempty" url:"CANCELLED,omitempty"`
	Completed        []interface{}                    `json:"COMPLETED,omitempty" url:"COMPLETED,omitempty"`
	Errored          []interface{}                    `json:"ERRORED,omitempty" url:"ERRORED,omitempty"`
	WfChaining       *GeneratedMsgMinistepsWfchaining `json:"wfChaining,omitempty" url:"wfChaining,omitempty"`

	extraProperties map[string]interface{}
	rawJSON         json.RawMessage
}

func (g *GeneratedMsgMinistepsNotificationsEmail) GetApprovalRequired() []interface{} {
	if g == nil {
		return nil
	}
	return g.ApprovalRequired
}

func (g *GeneratedMsgMinistepsNotificationsEmail) GetCancelled() []interface{} {
	if g == nil {
		return nil
	}
	return g.Cancelled
}

func (g *GeneratedMsgMinistepsNotificationsEmail) GetCompleted() []interface{} {
	if g == nil {
		return nil
	}
	return g.Completed
}

func (g *GeneratedMsgMinistepsNotificationsEmail) GetErrored() []interface{} {
	if g == nil {
		return nil
	}
	return g.Errored
}

func (g *GeneratedMsgMinistepsNotificationsEmail) GetWfChaining() *GeneratedMsgMinistepsWfchaining {
	if g == nil {
		return nil
	}
	return g.WfChaining
}

func (g *GeneratedMsgMinistepsNotificationsEmail) GetExtraProperties() map[string]interface{} {
	return g.extraProperties
}

func (g *GeneratedMsgMinistepsNotificationsEmail) UnmarshalJSON(data []byte) error {
	type unmarshaler GeneratedMsgMinistepsNotificationsEmail
	var value unmarshaler
	if err := json.Unmarshal(data, &value); err != nil {
		return err
	}
	*g = GeneratedMsgMinistepsNotificationsEmail(value)
	extraProperties, err := internal.ExtractExtraProperties(data, *g)
	if err != nil {
		return err
	}
	g.extraProperties = extraProperties
	g.rawJSON = json.RawMessage(data)
	return nil
}

func (g *GeneratedMsgMinistepsNotificationsEmail) String() string {
	if len(g.rawJSON) > 0 {
		if value, err := internal.StringifyJSON(g.rawJSON); err == nil {
			return value
		}
	}
	if value, err := internal.StringifyJSON(g); err == nil {
		return value
	}
	return fmt.Sprintf("%#v", g)
}

type GeneratedMsgMinistepsWebhooks struct {
	Completed []*GeneratedMsgMinistepsWebhooksCompleted `json:"COMPLETED,omitempty" url:"COMPLETED,omitempty"`

	extraProperties map[string]interface{}
	rawJSON         json.RawMessage
}

func (g *GeneratedMsgMinistepsWebhooks) GetCompleted() []*GeneratedMsgMinistepsWebhooksCompleted {
	if g == nil {
		return nil
	}
	return g.Completed
}

func (g *GeneratedMsgMinistepsWebhooks) GetExtraProperties() map[string]interface{} {
	return g.extraProperties
}

func (g *GeneratedMsgMinistepsWebhooks) UnmarshalJSON(data []byte) error {
	type unmarshaler GeneratedMsgMinistepsWebhooks
	var value unmarshaler
	if err := json.Unmarshal(data, &value); err != nil {
		return err
	}
	*g = GeneratedMsgMinistepsWebhooks(value)
	extraProperties, err := internal.ExtractExtraProperties(data, *g)
	if err != nil {
		return err
	}
	g.extraProperties = extraProperties
	g.rawJSON = json.RawMessage(data)
	return nil
}

func (g *GeneratedMsgMinistepsWebhooks) String() string {
	if len(g.rawJSON) > 0 {
		if value, err := internal.StringifyJSON(g.rawJSON); err == nil {
			return value
		}
	}
	if value, err := internal.StringifyJSON(g); err == nil {
		return value
	}
	return fmt.Sprintf("%#v", g)
}

type GeneratedMsgMinistepsWebhooksCompleted struct {
	WebhookName   string                                        `json:"webhookName" url:"webhookName"`
	WebhookSecret string                                        `json:"webhookSecret" url:"webhookSecret"`
	WebhookUrl    string                                        `json:"webhookUrl" url:"webhookUrl"`
	DriftDetected []*GeneratedMsgMinistepsWebhooksDriftDetected `json:"DRIFT_DETECTED,omitempty" url:"DRIFT_DETECTED,omitempty"`

	extraProperties map[string]interface{}
	rawJSON         json.RawMessage
}

func (g *GeneratedMsgMinistepsWebhooksCompleted) GetWebhookName() string {
	if g == nil {
		return ""
	}
	return g.WebhookName
}

func (g *GeneratedMsgMinistepsWebhooksCompleted) GetWebhookSecret() string {
	if g == nil {
		return ""
	}
	return g.WebhookSecret
}

func (g *GeneratedMsgMinistepsWebhooksCompleted) GetWebhookUrl() string {
	if g == nil {
		return ""
	}
	return g.WebhookUrl
}

func (g *GeneratedMsgMinistepsWebhooksCompleted) GetDriftDetected() []*GeneratedMsgMinistepsWebhooksDriftDetected {
	if g == nil {
		return nil
	}
	return g.DriftDetected
}

func (g *GeneratedMsgMinistepsWebhooksCompleted) GetExtraProperties() map[string]interface{} {
	return g.extraProperties
}

func (g *GeneratedMsgMinistepsWebhooksCompleted) UnmarshalJSON(data []byte) error {
	type unmarshaler GeneratedMsgMinistepsWebhooksCompleted
	var value unmarshaler
	if err := json.Unmarshal(data, &value); err != nil {
		return err
	}
	*g = GeneratedMsgMinistepsWebhooksCompleted(value)
	extraProperties, err := internal.ExtractExtraProperties(data, *g)
	if err != nil {
		return err
	}
	g.extraProperties = extraProperties
	g.rawJSON = json.RawMessage(data)
	return nil
}

func (g *GeneratedMsgMinistepsWebhooksCompleted) String() string {
	if len(g.rawJSON) > 0 {
		if value, err := internal.StringifyJSON(g.rawJSON); err == nil {
			return value
		}
	}
	if value, err := internal.StringifyJSON(g); err == nil {
		return value
	}
	return fmt.Sprintf("%#v", g)
}

type GeneratedMsgMinistepsWebhooksDriftDetected struct {
	WebhookName   string                                  `json:"webhookName" url:"webhookName"`
	WebhookSecret string                                  `json:"webhookSecret" url:"webhookSecret"`
	WebhookUrl    string                                  `json:"webhookUrl" url:"webhookUrl"`
	Errored       []*GeneratedMsgMinistepsWebhooksErrored `json:"ERRORED,omitempty" url:"ERRORED,omitempty"`

	extraProperties map[string]interface{}
	rawJSON         json.RawMessage
}

func (g *GeneratedMsgMinistepsWebhooksDriftDetected) GetWebhookName() string {
	if g == nil {
		return ""
	}
	return g.WebhookName
}

func (g *GeneratedMsgMinistepsWebhooksDriftDetected) GetWebhookSecret() string {
	if g == nil {
		return ""
	}
	return g.WebhookSecret
}

func (g *GeneratedMsgMinistepsWebhooksDriftDetected) GetWebhookUrl() string {
	if g == nil {
		return ""
	}
	return g.WebhookUrl
}

func (g *GeneratedMsgMinistepsWebhooksDriftDetected) GetErrored() []*GeneratedMsgMinistepsWebhooksErrored {
	if g == nil {
		return nil
	}
	return g.Errored
}

func (g *GeneratedMsgMinistepsWebhooksDriftDetected) GetExtraProperties() map[string]interface{} {
	return g.extraProperties
}

func (g *GeneratedMsgMinistepsWebhooksDriftDetected) UnmarshalJSON(data []byte) error {
	type unmarshaler GeneratedMsgMinistepsWebhooksDriftDetected
	var value unmarshaler
	if err := json.Unmarshal(data, &value); err != nil {
		return err
	}
	*g = GeneratedMsgMinistepsWebhooksDriftDetected(value)
	extraProperties, err := internal.ExtractExtraProperties(data, *g)
	if err != nil {
		return err
	}
	g.extraProperties = extraProperties
	g.rawJSON = json.RawMessage(data)
	return nil
}

func (g *GeneratedMsgMinistepsWebhooksDriftDetected) String() string {
	if len(g.rawJSON) > 0 {
		if value, err := internal.StringifyJSON(g.rawJSON); err == nil {
			return value
		}
	}
	if value, err := internal.StringifyJSON(g); err == nil {
		return value
	}
	return fmt.Sprintf("%#v", g)
}

type GeneratedMsgMinistepsWebhooksErrored struct {
	WebhookName   string                              `json:"webhookName" url:"webhookName"`
	WebhookSecret string                              `json:"webhookSecret" url:"webhookSecret"`
	WebhookUrl    string                              `json:"webhookUrl" url:"webhookUrl"`
	Notifications *GeneratedMsgMinistepsNotifications `json:"notifications,omitempty" url:"notifications,omitempty"`

	extraProperties map[string]interface{}
	rawJSON         json.RawMessage
}

func (g *GeneratedMsgMinistepsWebhooksErrored) GetWebhookName() string {
	if g == nil {
		return ""
	}
	return g.WebhookName
}

func (g *GeneratedMsgMinistepsWebhooksErrored) GetWebhookSecret() string {
	if g == nil {
		return ""
	}
	return g.WebhookSecret
}

func (g *GeneratedMsgMinistepsWebhooksErrored) GetWebhookUrl() string {
	if g == nil {
		return ""
	}
	return g.WebhookUrl
}

func (g *GeneratedMsgMinistepsWebhooksErrored) GetNotifications() *GeneratedMsgMinistepsNotifications {
	if g == nil {
		return nil
	}
	return g.Notifications
}

func (g *GeneratedMsgMinistepsWebhooksErrored) GetExtraProperties() map[string]interface{} {
	return g.extraProperties
}

func (g *GeneratedMsgMinistepsWebhooksErrored) UnmarshalJSON(data []byte) error {
	type unmarshaler GeneratedMsgMinistepsWebhooksErrored
	var value unmarshaler
	if err := json.Unmarshal(data, &value); err != nil {
		return err
	}
	*g = GeneratedMsgMinistepsWebhooksErrored(value)
	extraProperties, err := internal.ExtractExtraProperties(data, *g)
	if err != nil {
		return err
	}
	g.extraProperties = extraProperties
	g.rawJSON = json.RawMessage(data)
	return nil
}

func (g *GeneratedMsgMinistepsWebhooksErrored) String() string {
	if len(g.rawJSON) > 0 {
		if value, err := internal.StringifyJSON(g.rawJSON); err == nil {
			return value
		}
	}
	if value, err := internal.StringifyJSON(g); err == nil {
		return value
	}
	return fmt.Sprintf("%#v", g)
}

type GeneratedMsgMinistepsWfchaining struct {
	Completed            []interface{}                       `json:"COMPLETED,omitempty" url:"COMPLETED,omitempty"`
	Errored              []interface{}                       `json:"ERRORED,omitempty" url:"ERRORED,omitempty"`
	EnvironmentVariables []*GeneratedMsgEnvironmentvariables `json:"EnvironmentVariables,omitempty" url:"EnvironmentVariables,omitempty"`

	extraProperties map[string]interface{}
	rawJSON         json.RawMessage
}

func (g *GeneratedMsgMinistepsWfchaining) GetCompleted() []interface{} {
	if g == nil {
		return nil
	}
	return g.Completed
}

func (g *GeneratedMsgMinistepsWfchaining) GetErrored() []interface{} {
	if g == nil {
		return nil
	}
	return g.Errored
}

func (g *GeneratedMsgMinistepsWfchaining) GetEnvironmentVariables() []*GeneratedMsgEnvironmentvariables {
	if g == nil {
		return nil
	}
	return g.EnvironmentVariables
}

func (g *GeneratedMsgMinistepsWfchaining) GetExtraProperties() map[string]interface{} {
	return g.extraProperties
}

func (g *GeneratedMsgMinistepsWfchaining) UnmarshalJSON(data []byte) error {
	type unmarshaler GeneratedMsgMinistepsWfchaining
	var value unmarshaler
	if err := json.Unmarshal(data, &value); err != nil {
		return err
	}
	*g = GeneratedMsgMinistepsWfchaining(value)
	extraProperties, err := internal.ExtractExtraProperties(data, *g)
	if err != nil {
		return err
	}
	g.extraProperties = extraProperties
	g.rawJSON = json.RawMessage(data)
	return nil
}

func (g *GeneratedMsgMinistepsWfchaining) String() string {
	if len(g.rawJSON) > 0 {
		if value, err := internal.StringifyJSON(g.rawJSON); err == nil {
			return value
		}
	}
	if value, err := internal.StringifyJSON(g); err == nil {
		return value
	}
	return fmt.Sprintf("%#v", g)
}

type GeneratedMsgRunnerconstraints struct {
	Type                     string                                  `json:"type" url:"type"`
	DeploymentPlatformConfig []*GeneratedMsgDeploymentplatformconfig `json:"DeploymentPlatformConfig,omitempty" url:"DeploymentPlatformConfig,omitempty"`

	extraProperties map[string]interface{}
	rawJSON         json.RawMessage
}

func (g *GeneratedMsgRunnerconstraints) GetType() string {
	if g == nil {
		return ""
	}
	return g.Type
}

func (g *GeneratedMsgRunnerconstraints) GetDeploymentPlatformConfig() []*GeneratedMsgDeploymentplatformconfig {
	if g == nil {
		return nil
	}
	return g.DeploymentPlatformConfig
}

func (g *GeneratedMsgRunnerconstraints) GetExtraProperties() map[string]interface{} {
	return g.extraProperties
}

func (g *GeneratedMsgRunnerconstraints) UnmarshalJSON(data []byte) error {
	type unmarshaler GeneratedMsgRunnerconstraints
	var value unmarshaler
	if err := json.Unmarshal(data, &value); err != nil {
		return err
	}
	*g = GeneratedMsgRunnerconstraints(value)
	extraProperties, err := internal.ExtractExtraProperties(data, *g)
	if err != nil {
		return err
	}
	g.extraProperties = extraProperties
	g.rawJSON = json.RawMessage(data)
	return nil
}

func (g *GeneratedMsgRunnerconstraints) String() string {
	if len(g.rawJSON) > 0 {
		if value, err := internal.StringifyJSON(g.rawJSON); err == nil {
			return value
		}
	}
	if value, err := internal.StringifyJSON(g); err == nil {
		return value
	}
	return fmt.Sprintf("%#v", g)
}

type GeneratedMsgTerraformconfig struct {
	TerraformVersion       string                                               `json:"terraformVersion" url:"terraformVersion"`
	ApprovalPreApply       int                                                  `json:"approvalPreApply" url:"approvalPreApply"`
	ManagedTerraformState  int                                                  `json:"managedTerraformState" url:"managedTerraformState"`
	TerraformPlanOptions   string                                               `json:"terraformPlanOptions" url:"terraformPlanOptions"`
	TerraformInitOptions   string                                               `json:"terraformInitOptions" url:"terraformInitOptions"`
	DriftCheck             int                                                  `json:"driftCheck" url:"driftCheck"`
	PostApplyWfStepsConfig []*GeneratedMsgTerraformconfigPostapplywfstepsconfig `json:"postApplyWfStepsConfig,omitempty" url:"postApplyWfStepsConfig,omitempty"`

	extraProperties map[string]interface{}
	rawJSON         json.RawMessage
}

func (g *GeneratedMsgTerraformconfig) GetTerraformVersion() string {
	if g == nil {
		return ""
	}
	return g.TerraformVersion
}

func (g *GeneratedMsgTerraformconfig) GetApprovalPreApply() int {
	if g == nil {
		return 0
	}
	return g.ApprovalPreApply
}

func (g *GeneratedMsgTerraformconfig) GetManagedTerraformState() int {
	if g == nil {
		return 0
	}
	return g.ManagedTerraformState
}

func (g *GeneratedMsgTerraformconfig) GetTerraformPlanOptions() string {
	if g == nil {
		return ""
	}
	return g.TerraformPlanOptions
}

func (g *GeneratedMsgTerraformconfig) GetTerraformInitOptions() string {
	if g == nil {
		return ""
	}
	return g.TerraformInitOptions
}

func (g *GeneratedMsgTerraformconfig) GetDriftCheck() int {
	if g == nil {
		return 0
	}
	return g.DriftCheck
}

func (g *GeneratedMsgTerraformconfig) GetPostApplyWfStepsConfig() []*GeneratedMsgTerraformconfigPostapplywfstepsconfig {
	if g == nil {
		return nil
	}
	return g.PostApplyWfStepsConfig
}

func (g *GeneratedMsgTerraformconfig) GetExtraProperties() map[string]interface{} {
	return g.extraProperties
}

func (g *GeneratedMsgTerraformconfig) UnmarshalJSON(data []byte) error {
	type unmarshaler GeneratedMsgTerraformconfig
	var value unmarshaler
	if err := json.Unmarshal(data, &value); err != nil {
		return err
	}
	*g = GeneratedMsgTerraformconfig(value)
	extraProperties, err := internal.ExtractExtraProperties(data, *g)
	if err != nil {
		return err
	}
	g.extraProperties = extraProperties
	g.rawJSON = json.RawMessage(data)
	return nil
}

func (g *GeneratedMsgTerraformconfig) String() string {
	if len(g.rawJSON) > 0 {
		if value, err := internal.StringifyJSON(g.rawJSON); err == nil {
			return value
		}
	}
	if value, err := internal.StringifyJSON(g); err == nil {
		return value
	}
	return fmt.Sprintf("%#v", g)
}

type GeneratedMsgTerraformconfigPostapplywfstepsconfig struct {
	Name             string                                                            `json:"name" url:"name"`
	MountPoints      []interface{}                                                     `json:"mountPoints,omitempty" url:"mountPoints,omitempty"`
	WfStepTemplateId string                                                            `json:"wfStepTemplateId" url:"wfStepTemplateId"`
	CmdOverride      string                                                            `json:"cmdOverride" url:"cmdOverride"`
	Approval         int                                                               `json:"approval" url:"approval"`
	WfStepInputData  *GeneratedMsgTerraformconfigPostapplywfstepsconfigWfstepinputdata `json:"wfStepInputData,omitempty" url:"wfStepInputData,omitempty"`

	extraProperties map[string]interface{}
	rawJSON         json.RawMessage
}

func (g *GeneratedMsgTerraformconfigPostapplywfstepsconfig) GetName() string {
	if g == nil {
		return ""
	}
	return g.Name
}

func (g *GeneratedMsgTerraformconfigPostapplywfstepsconfig) GetMountPoints() []interface{} {
	if g == nil {
		return nil
	}
	return g.MountPoints
}

func (g *GeneratedMsgTerraformconfigPostapplywfstepsconfig) GetWfStepTemplateId() string {
	if g == nil {
		return ""
	}
	return g.WfStepTemplateId
}

func (g *GeneratedMsgTerraformconfigPostapplywfstepsconfig) GetCmdOverride() string {
	if g == nil {
		return ""
	}
	return g.CmdOverride
}

func (g *GeneratedMsgTerraformconfigPostapplywfstepsconfig) GetApproval() int {
	if g == nil {
		return 0
	}
	return g.Approval
}

func (g *GeneratedMsgTerraformconfigPostapplywfstepsconfig) GetWfStepInputData() *GeneratedMsgTerraformconfigPostapplywfstepsconfigWfstepinputdata {
	if g == nil {
		return nil
	}
	return g.WfStepInputData
}

func (g *GeneratedMsgTerraformconfigPostapplywfstepsconfig) GetExtraProperties() map[string]interface{} {
	return g.extraProperties
}

func (g *GeneratedMsgTerraformconfigPostapplywfstepsconfig) UnmarshalJSON(data []byte) error {
	type unmarshaler GeneratedMsgTerraformconfigPostapplywfstepsconfig
	var value unmarshaler
	if err := json.Unmarshal(data, &value); err != nil {
		return err
	}
	*g = GeneratedMsgTerraformconfigPostapplywfstepsconfig(value)
	extraProperties, err := internal.ExtractExtraProperties(data, *g)
	if err != nil {
		return err
	}
	g.extraProperties = extraProperties
	g.rawJSON = json.RawMessage(data)
	return nil
}

func (g *GeneratedMsgTerraformconfigPostapplywfstepsconfig) String() string {
	if len(g.rawJSON) > 0 {
		if value, err := internal.StringifyJSON(g.rawJSON); err == nil {
			return value
		}
	}
	if value, err := internal.StringifyJSON(g); err == nil {
		return value
	}
	return fmt.Sprintf("%#v", g)
}

type GeneratedMsgTerraformconfigPostapplywfstepsconfigWfstepinputdata struct {
	SchemaType string                                                                `json:"schemaType" url:"schemaType"`
	Data       *GeneratedMsgTerraformconfigPostapplywfstepsconfigWfstepinputdataData `json:"data,omitempty" url:"data,omitempty"`

	extraProperties map[string]interface{}
	rawJSON         json.RawMessage
}

func (g *GeneratedMsgTerraformconfigPostapplywfstepsconfigWfstepinputdata) GetSchemaType() string {
	if g == nil {
		return ""
	}
	return g.SchemaType
}

func (g *GeneratedMsgTerraformconfigPostapplywfstepsconfigWfstepinputdata) GetData() *GeneratedMsgTerraformconfigPostapplywfstepsconfigWfstepinputdataData {
	if g == nil {
		return nil
	}
	return g.Data
}

func (g *GeneratedMsgTerraformconfigPostapplywfstepsconfigWfstepinputdata) GetExtraProperties() map[string]interface{} {
	return g.extraProperties
}

func (g *GeneratedMsgTerraformconfigPostapplywfstepsconfigWfstepinputdata) UnmarshalJSON(data []byte) error {
	type unmarshaler GeneratedMsgTerraformconfigPostapplywfstepsconfigWfstepinputdata
	var value unmarshaler
	if err := json.Unmarshal(data, &value); err != nil {
		return err
	}
	*g = GeneratedMsgTerraformconfigPostapplywfstepsconfigWfstepinputdata(value)
	extraProperties, err := internal.ExtractExtraProperties(data, *g)
	if err != nil {
		return err
	}
	g.extraProperties = extraProperties
	g.rawJSON = json.RawMessage(data)
	return nil
}

func (g *GeneratedMsgTerraformconfigPostapplywfstepsconfigWfstepinputdata) String() string {
	if len(g.rawJSON) > 0 {
		if value, err := internal.StringifyJSON(g.rawJSON); err == nil {
			return value
		}
	}
	if value, err := internal.StringifyJSON(g); err == nil {
		return value
	}
	return fmt.Sprintf("%#v", g)
}

type GeneratedMsgTerraformconfigPostapplywfstepsconfigWfstepinputdataData struct {
	TerraformVersion      string                                             `json:"terraformVersion" url:"terraformVersion"`
	ManagedTerraformState int                                                `json:"managedTerraformState" url:"managedTerraformState"`
	TerraformAction       string                                             `json:"terraformAction" url:"terraformAction"`
	PrePlanWfStepsConfig  []*GeneratedMsgTerraformconfigPreplanwfstepsconfig `json:"prePlanWfStepsConfig,omitempty" url:"prePlanWfStepsConfig,omitempty"`

	extraProperties map[string]interface{}
	rawJSON         json.RawMessage
}

func (g *GeneratedMsgTerraformconfigPostapplywfstepsconfigWfstepinputdataData) GetTerraformVersion() string {
	if g == nil {
		return ""
	}
	return g.TerraformVersion
}

func (g *GeneratedMsgTerraformconfigPostapplywfstepsconfigWfstepinputdataData) GetManagedTerraformState() int {
	if g == nil {
		return 0
	}
	return g.ManagedTerraformState
}

func (g *GeneratedMsgTerraformconfigPostapplywfstepsconfigWfstepinputdataData) GetTerraformAction() string {
	if g == nil {
		return ""
	}
	return g.TerraformAction
}

func (g *GeneratedMsgTerraformconfigPostapplywfstepsconfigWfstepinputdataData) GetPrePlanWfStepsConfig() []*GeneratedMsgTerraformconfigPreplanwfstepsconfig {
	if g == nil {
		return nil
	}
	return g.PrePlanWfStepsConfig
}

func (g *GeneratedMsgTerraformconfigPostapplywfstepsconfigWfstepinputdataData) GetExtraProperties() map[string]interface{} {
	return g.extraProperties
}

func (g *GeneratedMsgTerraformconfigPostapplywfstepsconfigWfstepinputdataData) UnmarshalJSON(data []byte) error {
	type unmarshaler GeneratedMsgTerraformconfigPostapplywfstepsconfigWfstepinputdataData
	var value unmarshaler
	if err := json.Unmarshal(data, &value); err != nil {
		return err
	}
	*g = GeneratedMsgTerraformconfigPostapplywfstepsconfigWfstepinputdataData(value)
	extraProperties, err := internal.ExtractExtraProperties(data, *g)
	if err != nil {
		return err
	}
	g.extraProperties = extraProperties
	g.rawJSON = json.RawMessage(data)
	return nil
}

func (g *GeneratedMsgTerraformconfigPostapplywfstepsconfigWfstepinputdataData) String() string {
	if len(g.rawJSON) > 0 {
		if value, err := internal.StringifyJSON(g.rawJSON); err == nil {
			return value
		}
	}
	if value, err := internal.StringifyJSON(g); err == nil {
		return value
	}
	return fmt.Sprintf("%#v", g)
}

type GeneratedMsgTerraformconfigPreapplywfstepsconfig struct {
	Name             string                                                           `json:"name" url:"name"`
	MountPoints      []interface{}                                                    `json:"mountPoints,omitempty" url:"mountPoints,omitempty"`
	WfStepTemplateId string                                                           `json:"wfStepTemplateId" url:"wfStepTemplateId"`
	CmdOverride      string                                                           `json:"cmdOverride" url:"cmdOverride"`
	Approval         int                                                              `json:"approval" url:"approval"`
	WfStepInputData  *GeneratedMsgTerraformconfigPreapplywfstepsconfigWfstepinputdata `json:"wfStepInputData,omitempty" url:"wfStepInputData,omitempty"`

	extraProperties map[string]interface{}
	rawJSON         json.RawMessage
}

func (g *GeneratedMsgTerraformconfigPreapplywfstepsconfig) GetName() string {
	if g == nil {
		return ""
	}
	return g.Name
}

func (g *GeneratedMsgTerraformconfigPreapplywfstepsconfig) GetMountPoints() []interface{} {
	if g == nil {
		return nil
	}
	return g.MountPoints
}

func (g *GeneratedMsgTerraformconfigPreapplywfstepsconfig) GetWfStepTemplateId() string {
	if g == nil {
		return ""
	}
	return g.WfStepTemplateId
}

func (g *GeneratedMsgTerraformconfigPreapplywfstepsconfig) GetCmdOverride() string {
	if g == nil {
		return ""
	}
	return g.CmdOverride
}

func (g *GeneratedMsgTerraformconfigPreapplywfstepsconfig) GetApproval() int {
	if g == nil {
		return 0
	}
	return g.Approval
}

func (g *GeneratedMsgTerraformconfigPreapplywfstepsconfig) GetWfStepInputData() *GeneratedMsgTerraformconfigPreapplywfstepsconfigWfstepinputdata {
	if g == nil {
		return nil
	}
	return g.WfStepInputData
}

func (g *GeneratedMsgTerraformconfigPreapplywfstepsconfig) GetExtraProperties() map[string]interface{} {
	return g.extraProperties
}

func (g *GeneratedMsgTerraformconfigPreapplywfstepsconfig) UnmarshalJSON(data []byte) error {
	type unmarshaler GeneratedMsgTerraformconfigPreapplywfstepsconfig
	var value unmarshaler
	if err := json.Unmarshal(data, &value); err != nil {
		return err
	}
	*g = GeneratedMsgTerraformconfigPreapplywfstepsconfig(value)
	extraProperties, err := internal.ExtractExtraProperties(data, *g)
	if err != nil {
		return err
	}
	g.extraProperties = extraProperties
	g.rawJSON = json.RawMessage(data)
	return nil
}

func (g *GeneratedMsgTerraformconfigPreapplywfstepsconfig) String() string {
	if len(g.rawJSON) > 0 {
		if value, err := internal.StringifyJSON(g.rawJSON); err == nil {
			return value
		}
	}
	if value, err := internal.StringifyJSON(g); err == nil {
		return value
	}
	return fmt.Sprintf("%#v", g)
}

type GeneratedMsgTerraformconfigPreapplywfstepsconfigWfstepinputdata struct {
	SchemaType string                                                               `json:"schemaType" url:"schemaType"`
	Data       *GeneratedMsgTerraformconfigPreapplywfstepsconfigWfstepinputdataData `json:"data,omitempty" url:"data,omitempty"`

	extraProperties map[string]interface{}
	rawJSON         json.RawMessage
}

func (g *GeneratedMsgTerraformconfigPreapplywfstepsconfigWfstepinputdata) GetSchemaType() string {
	if g == nil {
		return ""
	}
	return g.SchemaType
}

func (g *GeneratedMsgTerraformconfigPreapplywfstepsconfigWfstepinputdata) GetData() *GeneratedMsgTerraformconfigPreapplywfstepsconfigWfstepinputdataData {
	if g == nil {
		return nil
	}
	return g.Data
}

func (g *GeneratedMsgTerraformconfigPreapplywfstepsconfigWfstepinputdata) GetExtraProperties() map[string]interface{} {
	return g.extraProperties
}

func (g *GeneratedMsgTerraformconfigPreapplywfstepsconfigWfstepinputdata) UnmarshalJSON(data []byte) error {
	type unmarshaler GeneratedMsgTerraformconfigPreapplywfstepsconfigWfstepinputdata
	var value unmarshaler
	if err := json.Unmarshal(data, &value); err != nil {
		return err
	}
	*g = GeneratedMsgTerraformconfigPreapplywfstepsconfigWfstepinputdata(value)
	extraProperties, err := internal.ExtractExtraProperties(data, *g)
	if err != nil {
		return err
	}
	g.extraProperties = extraProperties
	g.rawJSON = json.RawMessage(data)
	return nil
}

func (g *GeneratedMsgTerraformconfigPreapplywfstepsconfigWfstepinputdata) String() string {
	if len(g.rawJSON) > 0 {
		if value, err := internal.StringifyJSON(g.rawJSON); err == nil {
			return value
		}
	}
	if value, err := internal.StringifyJSON(g); err == nil {
		return value
	}
	return fmt.Sprintf("%#v", g)
}

type GeneratedMsgTerraformconfigPreapplywfstepsconfigWfstepinputdataData struct {
	TerraformVersion      string `json:"terraformVersion" url:"terraformVersion"`
	ManagedTerraformState int    `json:"managedTerraformState" url:"managedTerraformState"`
	TerraformAction       string `json:"terraformAction" url:"terraformAction"`

	extraProperties map[string]interface{}
	rawJSON         json.RawMessage
}

func (g *GeneratedMsgTerraformconfigPreapplywfstepsconfigWfstepinputdataData) GetTerraformVersion() string {
	if g == nil {
		return ""
	}
	return g.TerraformVersion
}

func (g *GeneratedMsgTerraformconfigPreapplywfstepsconfigWfstepinputdataData) GetManagedTerraformState() int {
	if g == nil {
		return 0
	}
	return g.ManagedTerraformState
}

func (g *GeneratedMsgTerraformconfigPreapplywfstepsconfigWfstepinputdataData) GetTerraformAction() string {
	if g == nil {
		return ""
	}
	return g.TerraformAction
}

func (g *GeneratedMsgTerraformconfigPreapplywfstepsconfigWfstepinputdataData) GetExtraProperties() map[string]interface{} {
	return g.extraProperties
}

func (g *GeneratedMsgTerraformconfigPreapplywfstepsconfigWfstepinputdataData) UnmarshalJSON(data []byte) error {
	type unmarshaler GeneratedMsgTerraformconfigPreapplywfstepsconfigWfstepinputdataData
	var value unmarshaler
	if err := json.Unmarshal(data, &value); err != nil {
		return err
	}
	*g = GeneratedMsgTerraformconfigPreapplywfstepsconfigWfstepinputdataData(value)
	extraProperties, err := internal.ExtractExtraProperties(data, *g)
	if err != nil {
		return err
	}
	g.extraProperties = extraProperties
	g.rawJSON = json.RawMessage(data)
	return nil
}

func (g *GeneratedMsgTerraformconfigPreapplywfstepsconfigWfstepinputdataData) String() string {
	if len(g.rawJSON) > 0 {
		if value, err := internal.StringifyJSON(g.rawJSON); err == nil {
			return value
		}
	}
	if value, err := internal.StringifyJSON(g); err == nil {
		return value
	}
	return fmt.Sprintf("%#v", g)
}

type GeneratedMsgTerraformconfigPreplanwfstepsconfig struct {
	Name             string                                                          `json:"name" url:"name"`
	MountPoints      []interface{}                                                   `json:"mountPoints,omitempty" url:"mountPoints,omitempty"`
	WfStepTemplateId string                                                          `json:"wfStepTemplateId" url:"wfStepTemplateId"`
	CmdOverride      string                                                          `json:"cmdOverride" url:"cmdOverride"`
	Approval         int                                                             `json:"approval" url:"approval"`
	WfStepInputData  *GeneratedMsgTerraformconfigPreplanwfstepsconfigWfstepinputdata `json:"wfStepInputData,omitempty" url:"wfStepInputData,omitempty"`

	extraProperties map[string]interface{}
	rawJSON         json.RawMessage
}

func (g *GeneratedMsgTerraformconfigPreplanwfstepsconfig) GetName() string {
	if g == nil {
		return ""
	}
	return g.Name
}

func (g *GeneratedMsgTerraformconfigPreplanwfstepsconfig) GetMountPoints() []interface{} {
	if g == nil {
		return nil
	}
	return g.MountPoints
}

func (g *GeneratedMsgTerraformconfigPreplanwfstepsconfig) GetWfStepTemplateId() string {
	if g == nil {
		return ""
	}
	return g.WfStepTemplateId
}

func (g *GeneratedMsgTerraformconfigPreplanwfstepsconfig) GetCmdOverride() string {
	if g == nil {
		return ""
	}
	return g.CmdOverride
}

func (g *GeneratedMsgTerraformconfigPreplanwfstepsconfig) GetApproval() int {
	if g == nil {
		return 0
	}
	return g.Approval
}

func (g *GeneratedMsgTerraformconfigPreplanwfstepsconfig) GetWfStepInputData() *GeneratedMsgTerraformconfigPreplanwfstepsconfigWfstepinputdata {
	if g == nil {
		return nil
	}
	return g.WfStepInputData
}

func (g *GeneratedMsgTerraformconfigPreplanwfstepsconfig) GetExtraProperties() map[string]interface{} {
	return g.extraProperties
}

func (g *GeneratedMsgTerraformconfigPreplanwfstepsconfig) UnmarshalJSON(data []byte) error {
	type unmarshaler GeneratedMsgTerraformconfigPreplanwfstepsconfig
	var value unmarshaler
	if err := json.Unmarshal(data, &value); err != nil {
		return err
	}
	*g = GeneratedMsgTerraformconfigPreplanwfstepsconfig(value)
	extraProperties, err := internal.ExtractExtraProperties(data, *g)
	if err != nil {
		return err
	}
	g.extraProperties = extraProperties
	g.rawJSON = json.RawMessage(data)
	return nil
}

func (g *GeneratedMsgTerraformconfigPreplanwfstepsconfig) String() string {
	if len(g.rawJSON) > 0 {
		if value, err := internal.StringifyJSON(g.rawJSON); err == nil {
			return value
		}
	}
	if value, err := internal.StringifyJSON(g); err == nil {
		return value
	}
	return fmt.Sprintf("%#v", g)
}

type GeneratedMsgTerraformconfigPreplanwfstepsconfigWfstepinputdata struct {
	SchemaType string                                                              `json:"schemaType" url:"schemaType"`
	Data       *GeneratedMsgTerraformconfigPreplanwfstepsconfigWfstepinputdataData `json:"data,omitempty" url:"data,omitempty"`

	extraProperties map[string]interface{}
	rawJSON         json.RawMessage
}

func (g *GeneratedMsgTerraformconfigPreplanwfstepsconfigWfstepinputdata) GetSchemaType() string {
	if g == nil {
		return ""
	}
	return g.SchemaType
}

func (g *GeneratedMsgTerraformconfigPreplanwfstepsconfigWfstepinputdata) GetData() *GeneratedMsgTerraformconfigPreplanwfstepsconfigWfstepinputdataData {
	if g == nil {
		return nil
	}
	return g.Data
}

func (g *GeneratedMsgTerraformconfigPreplanwfstepsconfigWfstepinputdata) GetExtraProperties() map[string]interface{} {
	return g.extraProperties
}

func (g *GeneratedMsgTerraformconfigPreplanwfstepsconfigWfstepinputdata) UnmarshalJSON(data []byte) error {
	type unmarshaler GeneratedMsgTerraformconfigPreplanwfstepsconfigWfstepinputdata
	var value unmarshaler
	if err := json.Unmarshal(data, &value); err != nil {
		return err
	}
	*g = GeneratedMsgTerraformconfigPreplanwfstepsconfigWfstepinputdata(value)
	extraProperties, err := internal.ExtractExtraProperties(data, *g)
	if err != nil {
		return err
	}
	g.extraProperties = extraProperties
	g.rawJSON = json.RawMessage(data)
	return nil
}

func (g *GeneratedMsgTerraformconfigPreplanwfstepsconfigWfstepinputdata) String() string {
	if len(g.rawJSON) > 0 {
		if value, err := internal.StringifyJSON(g.rawJSON); err == nil {
			return value
		}
	}
	if value, err := internal.StringifyJSON(g); err == nil {
		return value
	}
	return fmt.Sprintf("%#v", g)
}

type GeneratedMsgTerraformconfigPreplanwfstepsconfigWfstepinputdataData struct {
	TerraformVersion      string                                              `json:"terraformVersion" url:"terraformVersion"`
	ManagedTerraformState int                                                 `json:"managedTerraformState" url:"managedTerraformState"`
	TerraformAction       string                                              `json:"terraformAction" url:"terraformAction"`
	PreApplyWfStepsConfig []*GeneratedMsgTerraformconfigPreapplywfstepsconfig `json:"preApplyWfStepsConfig,omitempty" url:"preApplyWfStepsConfig,omitempty"`

	extraProperties map[string]interface{}
	rawJSON         json.RawMessage
}

func (g *GeneratedMsgTerraformconfigPreplanwfstepsconfigWfstepinputdataData) GetTerraformVersion() string {
	if g == nil {
		return ""
	}
	return g.TerraformVersion
}

func (g *GeneratedMsgTerraformconfigPreplanwfstepsconfigWfstepinputdataData) GetManagedTerraformState() int {
	if g == nil {
		return 0
	}
	return g.ManagedTerraformState
}

func (g *GeneratedMsgTerraformconfigPreplanwfstepsconfigWfstepinputdataData) GetTerraformAction() string {
	if g == nil {
		return ""
	}
	return g.TerraformAction
}

func (g *GeneratedMsgTerraformconfigPreplanwfstepsconfigWfstepinputdataData) GetPreApplyWfStepsConfig() []*GeneratedMsgTerraformconfigPreapplywfstepsconfig {
	if g == nil {
		return nil
	}
	return g.PreApplyWfStepsConfig
}

func (g *GeneratedMsgTerraformconfigPreplanwfstepsconfigWfstepinputdataData) GetExtraProperties() map[string]interface{} {
	return g.extraProperties
}

func (g *GeneratedMsgTerraformconfigPreplanwfstepsconfigWfstepinputdataData) UnmarshalJSON(data []byte) error {
	type unmarshaler GeneratedMsgTerraformconfigPreplanwfstepsconfigWfstepinputdataData
	var value unmarshaler
	if err := json.Unmarshal(data, &value); err != nil {
		return err
	}
	*g = GeneratedMsgTerraformconfigPreplanwfstepsconfigWfstepinputdataData(value)
	extraProperties, err := internal.ExtractExtraProperties(data, *g)
	if err != nil {
		return err
	}
	g.extraProperties = extraProperties
	g.rawJSON = json.RawMessage(data)
	return nil
}

func (g *GeneratedMsgTerraformconfigPreplanwfstepsconfigWfstepinputdataData) String() string {
	if len(g.rawJSON) > 0 {
		if value, err := internal.StringifyJSON(g.rawJSON); err == nil {
			return value
		}
	}
	if value, err := internal.StringifyJSON(g); err == nil {
		return value
	}
	return fmt.Sprintf("%#v", g)
}

type GeneratedMsgVcsconfig struct {
	IacVcsConfig *GeneratedMsgVcsconfigIacvcsconfig `json:"iacVCSConfig,omitempty" url:"iacVCSConfig,omitempty"`

	extraProperties map[string]interface{}
	rawJSON         json.RawMessage
}

func (g *GeneratedMsgVcsconfig) GetIacVcsConfig() *GeneratedMsgVcsconfigIacvcsconfig {
	if g == nil {
		return nil
	}
	return g.IacVcsConfig
}

func (g *GeneratedMsgVcsconfig) GetExtraProperties() map[string]interface{} {
	return g.extraProperties
}

func (g *GeneratedMsgVcsconfig) UnmarshalJSON(data []byte) error {
	type unmarshaler GeneratedMsgVcsconfig
	var value unmarshaler
	if err := json.Unmarshal(data, &value); err != nil {
		return err
	}
	*g = GeneratedMsgVcsconfig(value)
	extraProperties, err := internal.ExtractExtraProperties(data, *g)
	if err != nil {
		return err
	}
	g.extraProperties = extraProperties
	g.rawJSON = json.RawMessage(data)
	return nil
}

func (g *GeneratedMsgVcsconfig) String() string {
	if len(g.rawJSON) > 0 {
		if value, err := internal.StringifyJSON(g.rawJSON); err == nil {
			return value
		}
	}
	if value, err := internal.StringifyJSON(g); err == nil {
		return value
	}
	return fmt.Sprintf("%#v", g)
}

type GeneratedMsgVcsconfigIacinputdata struct {
	SchemaType string                                 `json:"schemaType" url:"schemaType"`
	Data       *GeneratedMsgVcsconfigIacinputdataData `json:"data,omitempty" url:"data,omitempty"`

	extraProperties map[string]interface{}
	rawJSON         json.RawMessage
}

func (g *GeneratedMsgVcsconfigIacinputdata) GetSchemaType() string {
	if g == nil {
		return ""
	}
	return g.SchemaType
}

func (g *GeneratedMsgVcsconfigIacinputdata) GetData() *GeneratedMsgVcsconfigIacinputdataData {
	if g == nil {
		return nil
	}
	return g.Data
}

func (g *GeneratedMsgVcsconfigIacinputdata) GetExtraProperties() map[string]interface{} {
	return g.extraProperties
}

func (g *GeneratedMsgVcsconfigIacinputdata) UnmarshalJSON(data []byte) error {
	type unmarshaler GeneratedMsgVcsconfigIacinputdata
	var value unmarshaler
	if err := json.Unmarshal(data, &value); err != nil {
		return err
	}
	*g = GeneratedMsgVcsconfigIacinputdata(value)
	extraProperties, err := internal.ExtractExtraProperties(data, *g)
	if err != nil {
		return err
	}
	g.extraProperties = extraProperties
	g.rawJSON = json.RawMessage(data)
	return nil
}

func (g *GeneratedMsgVcsconfigIacinputdata) String() string {
	if len(g.rawJSON) > 0 {
		if value, err := internal.StringifyJSON(g.rawJSON); err == nil {
			return value
		}
	}
	if value, err := internal.StringifyJSON(g); err == nil {
		return value
	}
	return fmt.Sprintf("%#v", g)
}

type GeneratedMsgVcsconfigIacinputdataData struct {
	BucketRegion    string                       `json:"bucket_region" url:"bucket_region"`
	TerraformConfig *GeneratedMsgTerraformconfig `json:"TerraformConfig,omitempty" url:"TerraformConfig,omitempty"`

	extraProperties map[string]interface{}
	rawJSON         json.RawMessage
}

func (g *GeneratedMsgVcsconfigIacinputdataData) GetBucketRegion() string {
	if g == nil {
		return ""
	}
	return g.BucketRegion
}

func (g *GeneratedMsgVcsconfigIacinputdataData) GetTerraformConfig() *GeneratedMsgTerraformconfig {
	if g == nil {
		return nil
	}
	return g.TerraformConfig
}

func (g *GeneratedMsgVcsconfigIacinputdataData) GetExtraProperties() map[string]interface{} {
	return g.extraProperties
}

func (g *GeneratedMsgVcsconfigIacinputdataData) UnmarshalJSON(data []byte) error {
	type unmarshaler GeneratedMsgVcsconfigIacinputdataData
	var value unmarshaler
	if err := json.Unmarshal(data, &value); err != nil {
		return err
	}
	*g = GeneratedMsgVcsconfigIacinputdataData(value)
	extraProperties, err := internal.ExtractExtraProperties(data, *g)
	if err != nil {
		return err
	}
	g.extraProperties = extraProperties
	g.rawJSON = json.RawMessage(data)
	return nil
}

func (g *GeneratedMsgVcsconfigIacinputdataData) String() string {
	if len(g.rawJSON) > 0 {
		if value, err := internal.StringifyJSON(g.rawJSON); err == nil {
			return value
		}
	}
	if value, err := internal.StringifyJSON(g); err == nil {
		return value
	}
	return fmt.Sprintf("%#v", g)
}

type GeneratedMsgVcsconfigIacvcsconfig struct {
	IacTemplateId          string                             `json:"iacTemplateId" url:"iacTemplateId"`
	UseMarketplaceTemplate int                                `json:"useMarketplaceTemplate" url:"useMarketplaceTemplate"`
	IacInputData           *GeneratedMsgVcsconfigIacinputdata `json:"iacInputData,omitempty" url:"iacInputData,omitempty"`

	extraProperties map[string]interface{}
	rawJSON         json.RawMessage
}

func (g *GeneratedMsgVcsconfigIacvcsconfig) GetIacTemplateId() string {
	if g == nil {
		return ""
	}
	return g.IacTemplateId
}

func (g *GeneratedMsgVcsconfigIacvcsconfig) GetUseMarketplaceTemplate() int {
	if g == nil {
		return 0
	}
	return g.UseMarketplaceTemplate
}

func (g *GeneratedMsgVcsconfigIacvcsconfig) GetIacInputData() *GeneratedMsgVcsconfigIacinputdata {
	if g == nil {
		return nil
	}
	return g.IacInputData
}

func (g *GeneratedMsgVcsconfigIacvcsconfig) GetExtraProperties() map[string]interface{} {
	return g.extraProperties
}

func (g *GeneratedMsgVcsconfigIacvcsconfig) UnmarshalJSON(data []byte) error {
	type unmarshaler GeneratedMsgVcsconfigIacvcsconfig
	var value unmarshaler
	if err := json.Unmarshal(data, &value); err != nil {
		return err
	}
	*g = GeneratedMsgVcsconfigIacvcsconfig(value)
	extraProperties, err := internal.ExtractExtraProperties(data, *g)
	if err != nil {
		return err
	}
	g.extraProperties = extraProperties
	g.rawJSON = json.RawMessage(data)
	return nil
}

func (g *GeneratedMsgVcsconfigIacvcsconfig) String() string {
	if len(g.rawJSON) > 0 {
		if value, err := internal.StringifyJSON(g.rawJSON); err == nil {
			return value
		}
	}
	if value, err := internal.StringifyJSON(g); err == nil {
		return value
	}
	return fmt.Sprintf("%#v", g)
}

type GeneratedWorkflowGetMsg struct {
	UserJobMemory             float64                        `json:"UserJobMemory" url:"UserJobMemory"`
	UserJobCpu                float64                        `json:"UserJobCPU" url:"UserJobCPU"`
	NumberOfApprovalsRequired float64                        `json:"NumberOfApprovalsRequired" url:"NumberOfApprovalsRequired"`
	IsActive                  *IsArchiveEnum                 `json:"IsActive,omitempty" url:"IsActive,omitempty"`
	Approvers                 []interface{}                  `json:"Approvers,omitempty" url:"Approvers,omitempty"`
	Tags                      []string                       `json:"Tags,omitempty" url:"Tags,omitempty"`
	Authors                   []string                       `json:"Authors,omitempty" url:"Authors,omitempty"`
	WfStepsConfig             []interface{}                  `json:"WfStepsConfig,omitempty" url:"WfStepsConfig,omitempty"`
	ActivitySubscribers       []string                       `json:"ActivitySubscribers,omitempty" url:"ActivitySubscribers,omitempty"`
	SubResourceId             string                         `json:"SubResourceId" url:"SubResourceId"`
	OrgId                     string                         `json:"OrgId" url:"OrgId"`
	CreatedAt                 float64                        `json:"CreatedAt" url:"CreatedAt"`
	IsArchive                 string                         `json:"IsArchive" url:"IsArchive"`
	Description               string                         `json:"Description" url:"Description"`
	ResourceId                string                         `json:"ResourceId" url:"ResourceId"`
	WfType                    string                         `json:"WfType" url:"WfType"`
	ModifiedAt                float64                        `json:"ModifiedAt" url:"ModifiedAt"`
	ParentId                  string                         `json:"ParentId" url:"ParentId"`
	ResourceType              string                         `json:"ResourceType" url:"ResourceType"`
	LatestWfrunStatus         string                         `json:"LatestWfrunStatus" url:"LatestWfrunStatus"`
	DocVersion                string                         `json:"DocVersion" url:"DocVersion"`
	EnforcedPolicies          []interface{}                  `json:"EnforcedPolicies,omitempty" url:"EnforcedPolicies,omitempty"`
	ResourceName              string                         `json:"ResourceName" url:"ResourceName"`
	RunnerConstraints         *GeneratedMsgRunnerconstraints `json:"RunnerConstraints,omitempty" url:"RunnerConstraints,omitempty"`

	extraProperties map[string]interface{}
	rawJSON         json.RawMessage
}

func (g *GeneratedWorkflowGetMsg) GetUserJobMemory() float64 {
	if g == nil {
		return 0
	}
	return g.UserJobMemory
}

func (g *GeneratedWorkflowGetMsg) GetUserJobCpu() float64 {
	if g == nil {
		return 0
	}
	return g.UserJobCpu
}

func (g *GeneratedWorkflowGetMsg) GetNumberOfApprovalsRequired() float64 {
	if g == nil {
		return 0
	}
	return g.NumberOfApprovalsRequired
}

func (g *GeneratedWorkflowGetMsg) GetIsActive() *IsArchiveEnum {
	if g == nil {
		return nil
	}
	return g.IsActive
}

func (g *GeneratedWorkflowGetMsg) GetApprovers() []interface{} {
	if g == nil {
		return nil
	}
	return g.Approvers
}

func (g *GeneratedWorkflowGetMsg) GetTags() []string {
	if g == nil {
		return nil
	}
	return g.Tags
}

func (g *GeneratedWorkflowGetMsg) GetAuthors() []string {
	if g == nil {
		return nil
	}
	return g.Authors
}

func (g *GeneratedWorkflowGetMsg) GetWfStepsConfig() []interface{} {
	if g == nil {
		return nil
	}
	return g.WfStepsConfig
}

func (g *GeneratedWorkflowGetMsg) GetActivitySubscribers() []string {
	if g == nil {
		return nil
	}
	return g.ActivitySubscribers
}

func (g *GeneratedWorkflowGetMsg) GetSubResourceId() string {
	if g == nil {
		return ""
	}
	return g.SubResourceId
}

func (g *GeneratedWorkflowGetMsg) GetOrgId() string {
	if g == nil {
		return ""
	}
	return g.OrgId
}

func (g *GeneratedWorkflowGetMsg) GetCreatedAt() float64 {
	if g == nil {
		return 0
	}
	return g.CreatedAt
}

func (g *GeneratedWorkflowGetMsg) GetIsArchive() string {
	if g == nil {
		return ""
	}
	return g.IsArchive
}

func (g *GeneratedWorkflowGetMsg) GetDescription() string {
	if g == nil {
		return ""
	}
	return g.Description
}

func (g *GeneratedWorkflowGetMsg) GetResourceId() string {
	if g == nil {
		return ""
	}
	return g.ResourceId
}

func (g *GeneratedWorkflowGetMsg) GetWfType() string {
	if g == nil {
		return ""
	}
	return g.WfType
}

func (g *GeneratedWorkflowGetMsg) GetModifiedAt() float64 {
	if g == nil {
		return 0
	}
	return g.ModifiedAt
}

func (g *GeneratedWorkflowGetMsg) GetParentId() string {
	if g == nil {
		return ""
	}
	return g.ParentId
}

func (g *GeneratedWorkflowGetMsg) GetResourceType() string {
	if g == nil {
		return ""
	}
	return g.ResourceType
}

func (g *GeneratedWorkflowGetMsg) GetLatestWfrunStatus() string {
	if g == nil {
		return ""
	}
	return g.LatestWfrunStatus
}

func (g *GeneratedWorkflowGetMsg) GetDocVersion() string {
	if g == nil {
		return ""
	}
	return g.DocVersion
}

func (g *GeneratedWorkflowGetMsg) GetEnforcedPolicies() []interface{} {
	if g == nil {
		return nil
	}
	return g.EnforcedPolicies
}

func (g *GeneratedWorkflowGetMsg) GetResourceName() string {
	if g == nil {
		return ""
	}
	return g.ResourceName
}

func (g *GeneratedWorkflowGetMsg) GetRunnerConstraints() *GeneratedMsgRunnerconstraints {
	if g == nil {
		return nil
	}
	return g.RunnerConstraints
}

func (g *GeneratedWorkflowGetMsg) GetExtraProperties() map[string]interface{} {
	return g.extraProperties
}

func (g *GeneratedWorkflowGetMsg) UnmarshalJSON(data []byte) error {
	type unmarshaler GeneratedWorkflowGetMsg
	var value unmarshaler
	if err := json.Unmarshal(data, &value); err != nil {
		return err
	}
	*g = GeneratedWorkflowGetMsg(value)
	extraProperties, err := internal.ExtractExtraProperties(data, *g)
	if err != nil {
		return err
	}
	g.extraProperties = extraProperties
	g.rawJSON = json.RawMessage(data)
	return nil
}

func (g *GeneratedWorkflowGetMsg) String() string {
	if len(g.rawJSON) > 0 {
		if value, err := internal.StringifyJSON(g.rawJSON); err == nil {
			return value
		}
	}
	if value, err := internal.StringifyJSON(g); err == nil {
		return value
	}
	return fmt.Sprintf("%#v", g)
}

type GeneratedWorkflowListAllArtifactsResponse struct {
	Msg  string                                         `json:"msg" url:"msg"`
	Data *GeneratedWorkflowListAllArtifactsResponseData `json:"data,omitempty" url:"data,omitempty"`

	extraProperties map[string]interface{}
	rawJSON         json.RawMessage
}

func (g *GeneratedWorkflowListAllArtifactsResponse) GetMsg() string {
	if g == nil {
		return ""
	}
	return g.Msg
}

func (g *GeneratedWorkflowListAllArtifactsResponse) GetData() *GeneratedWorkflowListAllArtifactsResponseData {
	if g == nil {
		return nil
	}
	return g.Data
}

func (g *GeneratedWorkflowListAllArtifactsResponse) GetExtraProperties() map[string]interface{} {
	return g.extraProperties
}

func (g *GeneratedWorkflowListAllArtifactsResponse) UnmarshalJSON(data []byte) error {
	type unmarshaler GeneratedWorkflowListAllArtifactsResponse
	var value unmarshaler
	if err := json.Unmarshal(data, &value); err != nil {
		return err
	}
	*g = GeneratedWorkflowListAllArtifactsResponse(value)
	extraProperties, err := internal.ExtractExtraProperties(data, *g)
	if err != nil {
		return err
	}
	g.extraProperties = extraProperties
	g.rawJSON = json.RawMessage(data)
	return nil
}

func (g *GeneratedWorkflowListAllArtifactsResponse) String() string {
	if len(g.rawJSON) > 0 {
		if value, err := internal.StringifyJSON(g.rawJSON); err == nil {
			return value
		}
	}
	if value, err := internal.StringifyJSON(g); err == nil {
		return value
	}
	return fmt.Sprintf("%#v", g)
}

type GeneratedWorkflowListAllArtifactsResponseData struct {
	Artifacts map[string]*GeneratedWorkflowListAllArtifactsResponseDataArtifacts `json:"artifacts,omitempty" url:"artifacts,omitempty"`

	extraProperties map[string]interface{}
	rawJSON         json.RawMessage
}

func (g *GeneratedWorkflowListAllArtifactsResponseData) GetArtifacts() map[string]*GeneratedWorkflowListAllArtifactsResponseDataArtifacts {
	if g == nil {
		return nil
	}
	return g.Artifacts
}

func (g *GeneratedWorkflowListAllArtifactsResponseData) GetExtraProperties() map[string]interface{} {
	return g.extraProperties
}

func (g *GeneratedWorkflowListAllArtifactsResponseData) UnmarshalJSON(data []byte) error {
	type unmarshaler GeneratedWorkflowListAllArtifactsResponseData
	var value unmarshaler
	if err := json.Unmarshal(data, &value); err != nil {
		return err
	}
	*g = GeneratedWorkflowListAllArtifactsResponseData(value)
	extraProperties, err := internal.ExtractExtraProperties(data, *g)
	if err != nil {
		return err
	}
	g.extraProperties = extraProperties
	g.rawJSON = json.RawMessage(data)
	return nil
}

func (g *GeneratedWorkflowListAllArtifactsResponseData) String() string {
	if len(g.rawJSON) > 0 {
		if value, err := internal.StringifyJSON(g.rawJSON); err == nil {
			return value
		}
	}
	if value, err := internal.StringifyJSON(g); err == nil {
		return value
	}
	return fmt.Sprintf("%#v", g)
}

type GeneratedWorkflowListAllArtifactsResponseDataArtifacts struct {
	Url          string `json:"url" url:"url"`
	LastModified string `json:"lastModified" url:"lastModified"`
	Size         int    `json:"size" url:"size"`

	extraProperties map[string]interface{}
	rawJSON         json.RawMessage
}

func (g *GeneratedWorkflowListAllArtifactsResponseDataArtifacts) GetUrl() string {
	if g == nil {
		return ""
	}
	return g.Url
}

func (g *GeneratedWorkflowListAllArtifactsResponseDataArtifacts) GetLastModified() string {
	if g == nil {
		return ""
	}
	return g.LastModified
}

func (g *GeneratedWorkflowListAllArtifactsResponseDataArtifacts) GetSize() int {
	if g == nil {
		return 0
	}
	return g.Size
}

func (g *GeneratedWorkflowListAllArtifactsResponseDataArtifacts) GetExtraProperties() map[string]interface{} {
	return g.extraProperties
}

func (g *GeneratedWorkflowListAllArtifactsResponseDataArtifacts) UnmarshalJSON(data []byte) error {
	type unmarshaler GeneratedWorkflowListAllArtifactsResponseDataArtifacts
	var value unmarshaler
	if err := json.Unmarshal(data, &value); err != nil {
		return err
	}
	*g = GeneratedWorkflowListAllArtifactsResponseDataArtifacts(value)
	extraProperties, err := internal.ExtractExtraProperties(data, *g)
	if err != nil {
		return err
	}
	g.extraProperties = extraProperties
	g.rawJSON = json.RawMessage(data)
	return nil
}

func (g *GeneratedWorkflowListAllArtifactsResponseDataArtifacts) String() string {
	if len(g.rawJSON) > 0 {
		if value, err := internal.StringifyJSON(g.rawJSON); err == nil {
			return value
		}
	}
	if value, err := internal.StringifyJSON(g); err == nil {
		return value
	}
	return fmt.Sprintf("%#v", g)
}

type GeneratedWorkflowOutputsResponse struct {
	Msg  string                                `json:"msg" url:"msg"`
	Data *GeneratedWorkflowOutputsResponseData `json:"data,omitempty" url:"data,omitempty"`

	extraProperties map[string]interface{}
	rawJSON         json.RawMessage
}

func (g *GeneratedWorkflowOutputsResponse) GetMsg() string {
	if g == nil {
		return ""
	}
	return g.Msg
}

func (g *GeneratedWorkflowOutputsResponse) GetData() *GeneratedWorkflowOutputsResponseData {
	if g == nil {
		return nil
	}
	return g.Data
}

func (g *GeneratedWorkflowOutputsResponse) GetExtraProperties() map[string]interface{} {
	return g.extraProperties
}

func (g *GeneratedWorkflowOutputsResponse) UnmarshalJSON(data []byte) error {
	type unmarshaler GeneratedWorkflowOutputsResponse
	var value unmarshaler
	if err := json.Unmarshal(data, &value); err != nil {
		return err
	}
	*g = GeneratedWorkflowOutputsResponse(value)
	extraProperties, err := internal.ExtractExtraProperties(data, *g)
	if err != nil {
		return err
	}
	g.extraProperties = extraProperties
	g.rawJSON = json.RawMessage(data)
	return nil
}

func (g *GeneratedWorkflowOutputsResponse) String() string {
	if len(g.rawJSON) > 0 {
		if value, err := internal.StringifyJSON(g.rawJSON); err == nil {
			return value
		}
	}
	if value, err := internal.StringifyJSON(g); err == nil {
		return value
	}
	return fmt.Sprintf("%#v", g)
}

type GeneratedWorkflowOutputsResponseData struct {
	OutputsSignedUrl string `json:"outputs_signed_url" url:"outputs_signed_url"`

	extraProperties map[string]interface{}
	rawJSON         json.RawMessage
}

func (g *GeneratedWorkflowOutputsResponseData) GetOutputsSignedUrl() string {
	if g == nil {
		return ""
	}
	return g.OutputsSignedUrl
}

func (g *GeneratedWorkflowOutputsResponseData) GetExtraProperties() map[string]interface{} {
	return g.extraProperties
}

func (g *GeneratedWorkflowOutputsResponseData) UnmarshalJSON(data []byte) error {
	type unmarshaler GeneratedWorkflowOutputsResponseData
	var value unmarshaler
	if err := json.Unmarshal(data, &value); err != nil {
		return err
	}
	*g = GeneratedWorkflowOutputsResponseData(value)
	extraProperties, err := internal.ExtractExtraProperties(data, *g)
	if err != nil {
		return err
	}
	g.extraProperties = extraProperties
	g.rawJSON = json.RawMessage(data)
	return nil
}

func (g *GeneratedWorkflowOutputsResponseData) String() string {
	if len(g.rawJSON) > 0 {
		if value, err := internal.StringifyJSON(g.rawJSON); err == nil {
			return value
		}
	}
	if value, err := internal.StringifyJSON(g); err == nil {
		return value
	}
	return fmt.Sprintf("%#v", g)
}

type GeneratedWorkflowRunLogs struct {
	Msg []*GeneratedWorkflowRunLogsMsg `json:"msg,omitempty" url:"msg,omitempty"`

	extraProperties map[string]interface{}
	rawJSON         json.RawMessage
}

func (g *GeneratedWorkflowRunLogs) GetMsg() []*GeneratedWorkflowRunLogsMsg {
	if g == nil {
		return nil
	}
	return g.Msg
}

func (g *GeneratedWorkflowRunLogs) GetExtraProperties() map[string]interface{} {
	return g.extraProperties
}

func (g *GeneratedWorkflowRunLogs) UnmarshalJSON(data []byte) error {
	type unmarshaler GeneratedWorkflowRunLogs
	var value unmarshaler
	if err := json.Unmarshal(data, &value); err != nil {
		return err
	}
	*g = GeneratedWorkflowRunLogs(value)
	extraProperties, err := internal.ExtractExtraProperties(data, *g)
	if err != nil {
		return err
	}
	g.extraProperties = extraProperties
	g.rawJSON = json.RawMessage(data)
	return nil
}

func (g *GeneratedWorkflowRunLogs) String() string {
	if len(g.rawJSON) > 0 {
		if value, err := internal.StringifyJSON(g.rawJSON); err == nil {
			return value
		}
	}
	if value, err := internal.StringifyJSON(g); err == nil {
		return value
	}
	return fmt.Sprintf("%#v", g)
}

type GeneratedWorkflowRunLogsMsg struct {
	LogUrl string `json:"logURL" url:"logURL"`

	extraProperties map[string]interface{}
	rawJSON         json.RawMessage
}

func (g *GeneratedWorkflowRunLogsMsg) GetLogUrl() string {
	if g == nil {
		return ""
	}
	return g.LogUrl
}

func (g *GeneratedWorkflowRunLogsMsg) GetExtraProperties() map[string]interface{} {
	return g.extraProperties
}

func (g *GeneratedWorkflowRunLogsMsg) UnmarshalJSON(data []byte) error {
	type unmarshaler GeneratedWorkflowRunLogsMsg
	var value unmarshaler
	if err := json.Unmarshal(data, &value); err != nil {
		return err
	}
	*g = GeneratedWorkflowRunLogsMsg(value)
	extraProperties, err := internal.ExtractExtraProperties(data, *g)
	if err != nil {
		return err
	}
	g.extraProperties = extraProperties
	g.rawJSON = json.RawMessage(data)
	return nil
}

func (g *GeneratedWorkflowRunLogsMsg) String() string {
	if len(g.rawJSON) > 0 {
		if value, err := internal.StringifyJSON(g.rawJSON); err == nil {
			return value
		}
	}
	if value, err := internal.StringifyJSON(g); err == nil {
		return value
	}
	return fmt.Sprintf("%#v", g)
}

type GeneratedWorkflowRunStackStatuses struct {
	Name      string  `json:"name" url:"name"`
	CreatedAt float64 `json:"createdAt" url:"createdAt"`

	extraProperties map[string]interface{}
	rawJSON         json.RawMessage
}

func (g *GeneratedWorkflowRunStackStatuses) GetName() string {
	if g == nil {
		return ""
	}
	return g.Name
}

func (g *GeneratedWorkflowRunStackStatuses) GetCreatedAt() float64 {
	if g == nil {
		return 0
	}
	return g.CreatedAt
}

func (g *GeneratedWorkflowRunStackStatuses) GetExtraProperties() map[string]interface{} {
	return g.extraProperties
}

func (g *GeneratedWorkflowRunStackStatuses) UnmarshalJSON(data []byte) error {
	type unmarshaler GeneratedWorkflowRunStackStatuses
	var value unmarshaler
	if err := json.Unmarshal(data, &value); err != nil {
		return err
	}
	*g = GeneratedWorkflowRunStackStatuses(value)
	extraProperties, err := internal.ExtractExtraProperties(data, *g)
	if err != nil {
		return err
	}
	g.extraProperties = extraProperties
	g.rawJSON = json.RawMessage(data)
	return nil
}

func (g *GeneratedWorkflowRunStackStatuses) String() string {
	if len(g.rawJSON) > 0 {
		if value, err := internal.StringifyJSON(g.rawJSON); err == nil {
			return value
		}
	}
	if value, err := internal.StringifyJSON(g); err == nil {
		return value
	}
	return fmt.Sprintf("%#v", g)
}

type GeneratedWorkflowUpdateResponse struct {
	Msg  string                               `json:"msg" url:"msg"`
	Data *GeneratedWorkflowUpdateResponseData `json:"data,omitempty" url:"data,omitempty"`

	extraProperties map[string]interface{}
	rawJSON         json.RawMessage
}

func (g *GeneratedWorkflowUpdateResponse) GetMsg() string {
	if g == nil {
		return ""
	}
	return g.Msg
}

func (g *GeneratedWorkflowUpdateResponse) GetData() *GeneratedWorkflowUpdateResponseData {
	if g == nil {
		return nil
	}
	return g.Data
}

func (g *GeneratedWorkflowUpdateResponse) GetExtraProperties() map[string]interface{} {
	return g.extraProperties
}

func (g *GeneratedWorkflowUpdateResponse) UnmarshalJSON(data []byte) error {
	type unmarshaler GeneratedWorkflowUpdateResponse
	var value unmarshaler
	if err := json.Unmarshal(data, &value); err != nil {
		return err
	}
	*g = GeneratedWorkflowUpdateResponse(value)
	extraProperties, err := internal.ExtractExtraProperties(data, *g)
	if err != nil {
		return err
	}
	g.extraProperties = extraProperties
	g.rawJSON = json.RawMessage(data)
	return nil
}

func (g *GeneratedWorkflowUpdateResponse) String() string {
	if len(g.rawJSON) > 0 {
		if value, err := internal.StringifyJSON(g.rawJSON); err == nil {
			return value
		}
	}
	if value, err := internal.StringifyJSON(g); err == nil {
		return value
	}
	return fmt.Sprintf("%#v", g)
}

type GeneratedWorkflowUpdateResponseData struct {
	UserJobMemory             float64                                               `json:"UserJobMemory" url:"UserJobMemory"`
	UserJobCpu                float64                                               `json:"UserJobCPU" url:"UserJobCPU"`
	NumberOfApprovalsRequired float64                                               `json:"NumberOfApprovalsRequired" url:"NumberOfApprovalsRequired"`
	GitHubComRepoId           *string                                               `json:"GitHubComRepoID,omitempty" url:"GitHubComRepoID,omitempty"`
	Description               string                                                `json:"Description" url:"Description"`
	ModifiedAt                float64                                               `json:"ModifiedAt" url:"ModifiedAt"`
	Approvers                 []interface{}                                         `json:"Approvers,omitempty" url:"Approvers,omitempty"`
	Tags                      []interface{}                                         `json:"Tags,omitempty" url:"Tags,omitempty"`
	DocVersion                string                                                `json:"DocVersion" url:"DocVersion"`
	EnvironmentVariables      []interface{}                                         `json:"EnvironmentVariables,omitempty" url:"EnvironmentVariables,omitempty"`
	RunnerConstraints         *GeneratedWorkflowUpdateResponseDataRunnerconstraints `json:"RunnerConstraints,omitempty" url:"RunnerConstraints,omitempty"`

	extraProperties map[string]interface{}
	rawJSON         json.RawMessage
}

func (g *GeneratedWorkflowUpdateResponseData) GetUserJobMemory() float64 {
	if g == nil {
		return 0
	}
	return g.UserJobMemory
}

func (g *GeneratedWorkflowUpdateResponseData) GetUserJobCpu() float64 {
	if g == nil {
		return 0
	}
	return g.UserJobCpu
}

func (g *GeneratedWorkflowUpdateResponseData) GetNumberOfApprovalsRequired() float64 {
	if g == nil {
		return 0
	}
	return g.NumberOfApprovalsRequired
}

func (g *GeneratedWorkflowUpdateResponseData) GetGitHubComRepoId() *string {
	if g == nil {
		return nil
	}
	return g.GitHubComRepoId
}

func (g *GeneratedWorkflowUpdateResponseData) GetDescription() string {
	if g == nil {
		return ""
	}
	return g.Description
}

func (g *GeneratedWorkflowUpdateResponseData) GetModifiedAt() float64 {
	if g == nil {
		return 0
	}
	return g.ModifiedAt
}

func (g *GeneratedWorkflowUpdateResponseData) GetApprovers() []interface{} {
	if g == nil {
		return nil
	}
	return g.Approvers
}

func (g *GeneratedWorkflowUpdateResponseData) GetTags() []interface{} {
	if g == nil {
		return nil
	}
	return g.Tags
}

func (g *GeneratedWorkflowUpdateResponseData) GetDocVersion() string {
	if g == nil {
		return ""
	}
	return g.DocVersion
}

func (g *GeneratedWorkflowUpdateResponseData) GetEnvironmentVariables() []interface{} {
	if g == nil {
		return nil
	}
	return g.EnvironmentVariables
}

func (g *GeneratedWorkflowUpdateResponseData) GetRunnerConstraints() *GeneratedWorkflowUpdateResponseDataRunnerconstraints {
	if g == nil {
		return nil
	}
	return g.RunnerConstraints
}

func (g *GeneratedWorkflowUpdateResponseData) GetExtraProperties() map[string]interface{} {
	return g.extraProperties
}

func (g *GeneratedWorkflowUpdateResponseData) UnmarshalJSON(data []byte) error {
	type unmarshaler GeneratedWorkflowUpdateResponseData
	var value unmarshaler
	if err := json.Unmarshal(data, &value); err != nil {
		return err
	}
	*g = GeneratedWorkflowUpdateResponseData(value)
	extraProperties, err := internal.ExtractExtraProperties(data, *g)
	if err != nil {
		return err
	}
	g.extraProperties = extraProperties
	g.rawJSON = json.RawMessage(data)
	return nil
}

func (g *GeneratedWorkflowUpdateResponseData) String() string {
	if len(g.rawJSON) > 0 {
		if value, err := internal.StringifyJSON(g.rawJSON); err == nil {
			return value
		}
	}
	if value, err := internal.StringifyJSON(g); err == nil {
		return value
	}
	return fmt.Sprintf("%#v", g)
}

type GeneratedWorkflowUpdateResponseDataDeploymentplatformconfig struct {
	Kind   string                                                             `json:"kind" url:"kind"`
	Config *GeneratedWorkflowUpdateResponseDataDeploymentplatformconfigConfig `json:"config,omitempty" url:"config,omitempty"`

	extraProperties map[string]interface{}
	rawJSON         json.RawMessage
}

func (g *GeneratedWorkflowUpdateResponseDataDeploymentplatformconfig) GetKind() string {
	if g == nil {
		return ""
	}
	return g.Kind
}

func (g *GeneratedWorkflowUpdateResponseDataDeploymentplatformconfig) GetConfig() *GeneratedWorkflowUpdateResponseDataDeploymentplatformconfigConfig {
	if g == nil {
		return nil
	}
	return g.Config
}

func (g *GeneratedWorkflowUpdateResponseDataDeploymentplatformconfig) GetExtraProperties() map[string]interface{} {
	return g.extraProperties
}

func (g *GeneratedWorkflowUpdateResponseDataDeploymentplatformconfig) UnmarshalJSON(data []byte) error {
	type unmarshaler GeneratedWorkflowUpdateResponseDataDeploymentplatformconfig
	var value unmarshaler
	if err := json.Unmarshal(data, &value); err != nil {
		return err
	}
	*g = GeneratedWorkflowUpdateResponseDataDeploymentplatformconfig(value)
	extraProperties, err := internal.ExtractExtraProperties(data, *g)
	if err != nil {
		return err
	}
	g.extraProperties = extraProperties
	g.rawJSON = json.RawMessage(data)
	return nil
}

func (g *GeneratedWorkflowUpdateResponseDataDeploymentplatformconfig) String() string {
	if len(g.rawJSON) > 0 {
		if value, err := internal.StringifyJSON(g.rawJSON); err == nil {
			return value
		}
	}
	if value, err := internal.StringifyJSON(g); err == nil {
		return value
	}
	return fmt.Sprintf("%#v", g)
}

type GeneratedWorkflowUpdateResponseDataDeploymentplatformconfigConfig struct {
	ProfileName   string                                        `json:"profileName" url:"profileName"`
	IntegrationId string                                        `json:"integrationId" url:"integrationId"`
	VcsConfig     *GeneratedWorkflowUpdateResponseDataVcsconfig `json:"VCSConfig,omitempty" url:"VCSConfig,omitempty"`

	extraProperties map[string]interface{}
	rawJSON         json.RawMessage
}

func (g *GeneratedWorkflowUpdateResponseDataDeploymentplatformconfigConfig) GetProfileName() string {
	if g == nil {
		return ""
	}
	return g.ProfileName
}

func (g *GeneratedWorkflowUpdateResponseDataDeploymentplatformconfigConfig) GetIntegrationId() string {
	if g == nil {
		return ""
	}
	return g.IntegrationId
}

func (g *GeneratedWorkflowUpdateResponseDataDeploymentplatformconfigConfig) GetVcsConfig() *GeneratedWorkflowUpdateResponseDataVcsconfig {
	if g == nil {
		return nil
	}
	return g.VcsConfig
}

func (g *GeneratedWorkflowUpdateResponseDataDeploymentplatformconfigConfig) GetExtraProperties() map[string]interface{} {
	return g.extraProperties
}

func (g *GeneratedWorkflowUpdateResponseDataDeploymentplatformconfigConfig) UnmarshalJSON(data []byte) error {
	type unmarshaler GeneratedWorkflowUpdateResponseDataDeploymentplatformconfigConfig
	var value unmarshaler
	if err := json.Unmarshal(data, &value); err != nil {
		return err
	}
	*g = GeneratedWorkflowUpdateResponseDataDeploymentplatformconfigConfig(value)
	extraProperties, err := internal.ExtractExtraProperties(data, *g)
	if err != nil {
		return err
	}
	g.extraProperties = extraProperties
	g.rawJSON = json.RawMessage(data)
	return nil
}

func (g *GeneratedWorkflowUpdateResponseDataDeploymentplatformconfigConfig) String() string {
	if len(g.rawJSON) > 0 {
		if value, err := internal.StringifyJSON(g.rawJSON); err == nil {
			return value
		}
	}
	if value, err := internal.StringifyJSON(g); err == nil {
		return value
	}
	return fmt.Sprintf("%#v", g)
}

type GeneratedWorkflowUpdateResponseDataRunnerconstraints struct {
	Type                     string                                                         `json:"type" url:"type"`
	Selectors                []string                                                       `json:"selectors,omitempty" url:"selectors,omitempty"`
	DeploymentPlatformConfig []*GeneratedWorkflowUpdateResponseDataDeploymentplatformconfig `json:"DeploymentPlatformConfig,omitempty" url:"DeploymentPlatformConfig,omitempty"`

	extraProperties map[string]interface{}
	rawJSON         json.RawMessage
}

func (g *GeneratedWorkflowUpdateResponseDataRunnerconstraints) GetType() string {
	if g == nil {
		return ""
	}
	return g.Type
}

func (g *GeneratedWorkflowUpdateResponseDataRunnerconstraints) GetSelectors() []string {
	if g == nil {
		return nil
	}
	return g.Selectors
}

func (g *GeneratedWorkflowUpdateResponseDataRunnerconstraints) GetDeploymentPlatformConfig() []*GeneratedWorkflowUpdateResponseDataDeploymentplatformconfig {
	if g == nil {
		return nil
	}
	return g.DeploymentPlatformConfig
}

func (g *GeneratedWorkflowUpdateResponseDataRunnerconstraints) GetExtraProperties() map[string]interface{} {
	return g.extraProperties
}

func (g *GeneratedWorkflowUpdateResponseDataRunnerconstraints) UnmarshalJSON(data []byte) error {
	type unmarshaler GeneratedWorkflowUpdateResponseDataRunnerconstraints
	var value unmarshaler
	if err := json.Unmarshal(data, &value); err != nil {
		return err
	}
	*g = GeneratedWorkflowUpdateResponseDataRunnerconstraints(value)
	extraProperties, err := internal.ExtractExtraProperties(data, *g)
	if err != nil {
		return err
	}
	g.extraProperties = extraProperties
	g.rawJSON = json.RawMessage(data)
	return nil
}

func (g *GeneratedWorkflowUpdateResponseDataRunnerconstraints) String() string {
	if len(g.rawJSON) > 0 {
		if value, err := internal.StringifyJSON(g.rawJSON); err == nil {
			return value
		}
	}
	if value, err := internal.StringifyJSON(g); err == nil {
		return value
	}
	return fmt.Sprintf("%#v", g)
}

type GeneratedWorkflowUpdateResponseDataVcsconfig struct {
	IacVcsConfig *GeneratedWorkflowUpdateResponseDataVcsconfigIacvcsconfig `json:"iacVCSConfig,omitempty" url:"iacVCSConfig,omitempty"`

	extraProperties map[string]interface{}
	rawJSON         json.RawMessage
}

func (g *GeneratedWorkflowUpdateResponseDataVcsconfig) GetIacVcsConfig() *GeneratedWorkflowUpdateResponseDataVcsconfigIacvcsconfig {
	if g == nil {
		return nil
	}
	return g.IacVcsConfig
}

func (g *GeneratedWorkflowUpdateResponseDataVcsconfig) GetExtraProperties() map[string]interface{} {
	return g.extraProperties
}

func (g *GeneratedWorkflowUpdateResponseDataVcsconfig) UnmarshalJSON(data []byte) error {
	type unmarshaler GeneratedWorkflowUpdateResponseDataVcsconfig
	var value unmarshaler
	if err := json.Unmarshal(data, &value); err != nil {
		return err
	}
	*g = GeneratedWorkflowUpdateResponseDataVcsconfig(value)
	extraProperties, err := internal.ExtractExtraProperties(data, *g)
	if err != nil {
		return err
	}
	g.extraProperties = extraProperties
	g.rawJSON = json.RawMessage(data)
	return nil
}

func (g *GeneratedWorkflowUpdateResponseDataVcsconfig) String() string {
	if len(g.rawJSON) > 0 {
		if value, err := internal.StringifyJSON(g.rawJSON); err == nil {
			return value
		}
	}
	if value, err := internal.StringifyJSON(g); err == nil {
		return value
	}
	return fmt.Sprintf("%#v", g)
}

type GeneratedWorkflowUpdateResponseDataVcsconfigIacvcsconfig struct {
	IacTemplateId          string `json:"iacTemplateId" url:"iacTemplateId"`
	UseMarketplaceTemplate bool   `json:"useMarketplaceTemplate" url:"useMarketplaceTemplate"`

	extraProperties map[string]interface{}
	rawJSON         json.RawMessage
}

func (g *GeneratedWorkflowUpdateResponseDataVcsconfigIacvcsconfig) GetIacTemplateId() string {
	if g == nil {
		return ""
	}
	return g.IacTemplateId
}

func (g *GeneratedWorkflowUpdateResponseDataVcsconfigIacvcsconfig) GetUseMarketplaceTemplate() bool {
	if g == nil {
		return false
	}
	return g.UseMarketplaceTemplate
}

func (g *GeneratedWorkflowUpdateResponseDataVcsconfigIacvcsconfig) GetExtraProperties() map[string]interface{} {
	return g.extraProperties
}

func (g *GeneratedWorkflowUpdateResponseDataVcsconfigIacvcsconfig) UnmarshalJSON(data []byte) error {
	type unmarshaler GeneratedWorkflowUpdateResponseDataVcsconfigIacvcsconfig
	var value unmarshaler
	if err := json.Unmarshal(data, &value); err != nil {
		return err
	}
	*g = GeneratedWorkflowUpdateResponseDataVcsconfigIacvcsconfig(value)
	extraProperties, err := internal.ExtractExtraProperties(data, *g)
	if err != nil {
		return err
	}
	g.extraProperties = extraProperties
	g.rawJSON = json.RawMessage(data)
	return nil
}

func (g *GeneratedWorkflowUpdateResponseDataVcsconfigIacvcsconfig) String() string {
	if len(g.rawJSON) > 0 {
		if value, err := internal.StringifyJSON(g.rawJSON); err == nil {
			return value
		}
	}
	if value, err := internal.StringifyJSON(g); err == nil {
		return value
	}
	return fmt.Sprintf("%#v", g)
}

type GeneratedWorkflowsListAllMsg struct {
	GitHubComRepoId   string        `json:"GitHubComRepoID" url:"GitHubComRepoID"`
	IsActive          string        `json:"IsActive" url:"IsActive"`
	Description       string        `json:"Description" url:"Description"`
	ResourceId        string        `json:"ResourceId" url:"ResourceId"`
	WfType            string        `json:"WfType" url:"WfType"`
	ModifiedAt        float64       `json:"ModifiedAt" url:"ModifiedAt"`
	ParentId          string        `json:"ParentId" url:"ParentId"`
	LatestWfrunStatus string        `json:"LatestWfrunStatus" url:"LatestWfrunStatus"`
	Tags              []interface{} `json:"Tags,omitempty" url:"Tags,omitempty"`
	Authors           []string      `json:"Authors,omitempty" url:"Authors,omitempty"`
	ResourceName      string        `json:"ResourceName" url:"ResourceName"`
	SubResourceId     string        `json:"SubResourceId" url:"SubResourceId"`
	CreatedAt         float64       `json:"CreatedAt" url:"CreatedAt"`

	extraProperties map[string]interface{}
	rawJSON         json.RawMessage
}

func (g *GeneratedWorkflowsListAllMsg) GetGitHubComRepoId() string {
	if g == nil {
		return ""
	}
	return g.GitHubComRepoId
}

func (g *GeneratedWorkflowsListAllMsg) GetIsActive() string {
	if g == nil {
		return ""
	}
	return g.IsActive
}

func (g *GeneratedWorkflowsListAllMsg) GetDescription() string {
	if g == nil {
		return ""
	}
	return g.Description
}

func (g *GeneratedWorkflowsListAllMsg) GetResourceId() string {
	if g == nil {
		return ""
	}
	return g.ResourceId
}

func (g *GeneratedWorkflowsListAllMsg) GetWfType() string {
	if g == nil {
		return ""
	}
	return g.WfType
}

func (g *GeneratedWorkflowsListAllMsg) GetModifiedAt() float64 {
	if g == nil {
		return 0
	}
	return g.ModifiedAt
}

func (g *GeneratedWorkflowsListAllMsg) GetParentId() string {
	if g == nil {
		return ""
	}
	return g.ParentId
}

func (g *GeneratedWorkflowsListAllMsg) GetLatestWfrunStatus() string {
	if g == nil {
		return ""
	}
	return g.LatestWfrunStatus
}

func (g *GeneratedWorkflowsListAllMsg) GetTags() []interface{} {
	if g == nil {
		return nil
	}
	return g.Tags
}

func (g *GeneratedWorkflowsListAllMsg) GetAuthors() []string {
	if g == nil {
		return nil
	}
	return g.Authors
}

func (g *GeneratedWorkflowsListAllMsg) GetResourceName() string {
	if g == nil {
		return ""
	}
	return g.ResourceName
}

func (g *GeneratedWorkflowsListAllMsg) GetSubResourceId() string {
	if g == nil {
		return ""
	}
	return g.SubResourceId
}

func (g *GeneratedWorkflowsListAllMsg) GetCreatedAt() float64 {
	if g == nil {
		return 0
	}
	return g.CreatedAt
}

func (g *GeneratedWorkflowsListAllMsg) GetExtraProperties() map[string]interface{} {
	return g.extraProperties
}

func (g *GeneratedWorkflowsListAllMsg) UnmarshalJSON(data []byte) error {
	type unmarshaler GeneratedWorkflowsListAllMsg
	var value unmarshaler
	if err := json.Unmarshal(data, &value); err != nil {
		return err
	}
	*g = GeneratedWorkflowsListAllMsg(value)
	extraProperties, err := internal.ExtractExtraProperties(data, *g)
	if err != nil {
		return err
	}
	g.extraProperties = extraProperties
	g.rawJSON = json.RawMessage(data)
	return nil
}

func (g *GeneratedWorkflowsListAllMsg) String() string {
	if len(g.rawJSON) > 0 {
		if value, err := internal.StringifyJSON(g.rawJSON); err == nil {
			return value
		}
	}
	if value, err := internal.StringifyJSON(g); err == nil {
		return value
	}
	return fmt.Sprintf("%#v", g)
}

type IacInputData struct {
	SchemaId   *string                    `json:"schemaId,omitempty" url:"schemaId,omitempty"`
	SchemaType IacInputDataSchemaTypeEnum `json:"schemaType" url:"schemaType"`
	Data       map[string]interface{}     `json:"data,omitempty" url:"data,omitempty"`

	extraProperties map[string]interface{}
	rawJSON         json.RawMessage
}

func (i *IacInputData) GetSchemaId() *string {
	if i == nil {
		return nil
	}
	return i.SchemaId
}

func (i *IacInputData) GetSchemaType() IacInputDataSchemaTypeEnum {
	if i == nil {
		return ""
	}
	return i.SchemaType
}

func (i *IacInputData) GetData() map[string]interface{} {
	if i == nil {
		return nil
	}
	return i.Data
}

func (i *IacInputData) GetExtraProperties() map[string]interface{} {
	return i.extraProperties
}

func (i *IacInputData) UnmarshalJSON(data []byte) error {
	type unmarshaler IacInputData
	var value unmarshaler
	if err := json.Unmarshal(data, &value); err != nil {
		return err
	}
	*i = IacInputData(value)
	extraProperties, err := internal.ExtractExtraProperties(data, *i)
	if err != nil {
		return err
	}
	i.extraProperties = extraProperties
	i.rawJSON = json.RawMessage(data)
	return nil
}

func (i *IacInputData) String() string {
	if len(i.rawJSON) > 0 {
		if value, err := internal.StringifyJSON(i.rawJSON); err == nil {
			return value
		}
	}
	if value, err := internal.StringifyJSON(i); err == nil {
		return value
	}
	return fmt.Sprintf("%#v", i)
}

// * `FORM_JSONSCHEMA` - FORM_JSONSCHEMA
// * `RAW_HCL` - RAW_HCL
// * `RAW_JSON` - RAW_JSON
// * `NONE` - NONE
type IacInputDataSchemaTypeEnum string

const (
	IacInputDataSchemaTypeEnumFormJsonschema IacInputDataSchemaTypeEnum = "FORM_JSONSCHEMA"
	IacInputDataSchemaTypeEnumRawHcl         IacInputDataSchemaTypeEnum = "RAW_HCL"
	IacInputDataSchemaTypeEnumRawJson        IacInputDataSchemaTypeEnum = "RAW_JSON"
	IacInputDataSchemaTypeEnumNone           IacInputDataSchemaTypeEnum = "NONE"
)

func NewIacInputDataSchemaTypeEnumFromString(s string) (IacInputDataSchemaTypeEnum, error) {
	switch s {
	case "FORM_JSONSCHEMA":
		return IacInputDataSchemaTypeEnumFormJsonschema, nil
	case "RAW_HCL":
		return IacInputDataSchemaTypeEnumRawHcl, nil
	case "RAW_JSON":
		return IacInputDataSchemaTypeEnumRawJson, nil
	case "NONE":
		return IacInputDataSchemaTypeEnumNone, nil
	}
	var t IacInputDataSchemaTypeEnum
	return "", fmt.Errorf("%s is not a valid %T", s, t)
}

func (i IacInputDataSchemaTypeEnum) Ptr() *IacInputDataSchemaTypeEnum {
	return &i
}

type IacvcsConfig struct {
	UseMarketplaceTemplate bool          `json:"useMarketplaceTemplate" url:"useMarketplaceTemplate"`
	IacTemplateId          *string       `json:"iacTemplateId,omitempty" url:"iacTemplateId,omitempty"`
	CustomSource           *CustomSource `json:"customSource,omitempty" url:"customSource,omitempty"`

	extraProperties map[string]interface{}
	rawJSON         json.RawMessage
}

func (i *IacvcsConfig) GetUseMarketplaceTemplate() bool {
	if i == nil {
		return false
	}
	return i.UseMarketplaceTemplate
}

func (i *IacvcsConfig) GetIacTemplateId() *string {
	if i == nil {
		return nil
	}
	return i.IacTemplateId
}

func (i *IacvcsConfig) GetCustomSource() *CustomSource {
	if i == nil {
		return nil
	}
	return i.CustomSource
}

func (i *IacvcsConfig) GetExtraProperties() map[string]interface{} {
	return i.extraProperties
}

func (i *IacvcsConfig) UnmarshalJSON(data []byte) error {
	type unmarshaler IacvcsConfig
	var value unmarshaler
	if err := json.Unmarshal(data, &value); err != nil {
		return err
	}
	*i = IacvcsConfig(value)
	extraProperties, err := internal.ExtractExtraProperties(data, *i)
	if err != nil {
		return err
	}
	i.extraProperties = extraProperties
	i.rawJSON = json.RawMessage(data)
	return nil
}

func (i *IacvcsConfig) String() string {
	if len(i.rawJSON) > 0 {
		if value, err := internal.StringifyJSON(i.rawJSON); err == nil {
			return value
		}
	}
	if value, err := internal.StringifyJSON(i); err == nil {
		return value
	}
	return fmt.Sprintf("%#v", i)
}

type InputSchemas struct {
	Id           *string              `json:"id,omitempty" url:"id,omitempty"`
	Name         *string              `json:"name,omitempty" url:"name,omitempty"`
	Description  *string              `json:"description,omitempty" url:"description,omitempty"`
	Type         InputSchemasTypeEnum `json:"type" url:"type"`
	EncodedData  *string              `json:"encodedData,omitempty" url:"encodedData,omitempty"`
	UiSchemaData *string              `json:"uiSchemaData,omitempty" url:"uiSchemaData,omitempty"`
	IsCommitted  *bool                `json:"isCommitted,omitempty" url:"isCommitted,omitempty"`

	extraProperties map[string]interface{}
	rawJSON         json.RawMessage
}

func (i *InputSchemas) GetId() *string {
	if i == nil {
		return nil
	}
	return i.Id
}

func (i *InputSchemas) GetName() *string {
	if i == nil {
		return nil
	}
	return i.Name
}

func (i *InputSchemas) GetDescription() *string {
	if i == nil {
		return nil
	}
	return i.Description
}

func (i *InputSchemas) GetType() InputSchemasTypeEnum {
	if i == nil {
		return ""
	}
	return i.Type
}

func (i *InputSchemas) GetEncodedData() *string {
	if i == nil {
		return nil
	}
	return i.EncodedData
}

func (i *InputSchemas) GetUiSchemaData() *string {
	if i == nil {
		return nil
	}
	return i.UiSchemaData
}

func (i *InputSchemas) GetIsCommitted() *bool {
	if i == nil {
		return nil
	}
	return i.IsCommitted
}

func (i *InputSchemas) GetExtraProperties() map[string]interface{} {
	return i.extraProperties
}

func (i *InputSchemas) UnmarshalJSON(data []byte) error {
	type unmarshaler InputSchemas
	var value unmarshaler
	if err := json.Unmarshal(data, &value); err != nil {
		return err
	}
	*i = InputSchemas(value)
	extraProperties, err := internal.ExtractExtraProperties(data, *i)
	if err != nil {
		return err
	}
	i.extraProperties = extraProperties
	i.rawJSON = json.RawMessage(data)
	return nil
}

func (i *InputSchemas) String() string {
	if len(i.rawJSON) > 0 {
		if value, err := internal.StringifyJSON(i.rawJSON); err == nil {
			return value
		}
	}
	if value, err := internal.StringifyJSON(i); err == nil {
		return value
	}
	return fmt.Sprintf("%#v", i)
}

// * `FORM_JSONSCHEMA` - FORM_JSONSCHEMA
// * `RAW_JSON` - RAW_JSON
// * `TIRITH_JSON` - TIRITH_JSON
type InputSchemasTypeEnum string

const (
	InputSchemasTypeEnumFormJsonschema InputSchemasTypeEnum = "FORM_JSONSCHEMA"
	InputSchemasTypeEnumRawJson        InputSchemasTypeEnum = "RAW_JSON"
	InputSchemasTypeEnumTirithJson     InputSchemasTypeEnum = "TIRITH_JSON"
)

func NewInputSchemasTypeEnumFromString(s string) (InputSchemasTypeEnum, error) {
	switch s {
	case "FORM_JSONSCHEMA":
		return InputSchemasTypeEnumFormJsonschema, nil
	case "RAW_JSON":
		return InputSchemasTypeEnumRawJson, nil
	case "TIRITH_JSON":
		return InputSchemasTypeEnumTirithJson, nil
	}
	var t InputSchemasTypeEnum
	return "", fmt.Errorf("%s is not a valid %T", s, t)
}

func (i InputSchemasTypeEnum) Ptr() *InputSchemasTypeEnum {
	return &i
}

// * `0` - 0
// * `1` - 1
type IsArchiveEnum string

const (
	IsArchiveEnumZero IsArchiveEnum = "0"
	IsArchiveEnumOne  IsArchiveEnum = "1"
)

func NewIsArchiveEnumFromString(s string) (IsArchiveEnum, error) {
	switch s {
	case "0":
		return IsArchiveEnumZero, nil
	case "1":
		return IsArchiveEnumOne, nil
	}
	var t IsArchiveEnum
	return "", fmt.Errorf("%s is not a valid %T", s, t)
}

func (i IsArchiveEnum) Ptr() *IsArchiveEnum {
	return &i
}

type MiniSteps struct {
	WorkflowGroupId    string                 `json:"workflowGroupId" url:"workflowGroupId"`
	WorkflowId         *string                `json:"workflowId,omitempty" url:"workflowId,omitempty"`
	StackId            *string                `json:"stackId,omitempty" url:"stackId,omitempty"`
	WorkflowRunPayload map[string]interface{} `json:"workflowRunPayload,omitempty" url:"workflowRunPayload,omitempty"`
	StackRunPayload    map[string]interface{} `json:"stackRunPayload,omitempty" url:"stackRunPayload,omitempty"`
	Conditions         map[string]interface{} `json:"conditions,omitempty" url:"conditions,omitempty"`

	extraProperties map[string]interface{}
	rawJSON         json.RawMessage
}

func (m *MiniSteps) GetWorkflowGroupId() string {
	if m == nil {
		return ""
	}
	return m.WorkflowGroupId
}

func (m *MiniSteps) GetWorkflowId() *string {
	if m == nil {
		return nil
	}
	return m.WorkflowId
}

func (m *MiniSteps) GetStackId() *string {
	if m == nil {
		return nil
	}
	return m.StackId
}

func (m *MiniSteps) GetWorkflowRunPayload() map[string]interface{} {
	if m == nil {
		return nil
	}
	return m.WorkflowRunPayload
}

func (m *MiniSteps) GetStackRunPayload() map[string]interface{} {
	if m == nil {
		return nil
	}
	return m.StackRunPayload
}

func (m *MiniSteps) GetConditions() map[string]interface{} {
	if m == nil {
		return nil
	}
	return m.Conditions
}

func (m *MiniSteps) GetExtraProperties() map[string]interface{} {
	return m.extraProperties
}

func (m *MiniSteps) UnmarshalJSON(data []byte) error {
	type unmarshaler MiniSteps
	var value unmarshaler
	if err := json.Unmarshal(data, &value); err != nil {
		return err
	}
	*m = MiniSteps(value)
	extraProperties, err := internal.ExtractExtraProperties(data, *m)
	if err != nil {
		return err
	}
	m.extraProperties = extraProperties
	m.rawJSON = json.RawMessage(data)
	return nil
}

func (m *MiniSteps) String() string {
	if len(m.rawJSON) > 0 {
		if value, err := internal.StringifyJSON(m.rawJSON); err == nil {
			return value
		}
	}
	if value, err := internal.StringifyJSON(m); err == nil {
		return value
	}
	return fmt.Sprintf("%#v", m)
}

type MiniStepsSchema struct {
	WfChaining    *WfChainingPayloadPayload `json:"wfChaining,omitempty" url:"wfChaining,omitempty"`
	Notifications *NotificationTypes        `json:"notifications,omitempty" url:"notifications,omitempty"`
	Webhooks      *WebhookTypes             `json:"webhooks,omitempty" url:"webhooks,omitempty"`

	extraProperties map[string]interface{}
	rawJSON         json.RawMessage
}

func (m *MiniStepsSchema) GetWfChaining() *WfChainingPayloadPayload {
	if m == nil {
		return nil
	}
	return m.WfChaining
}

func (m *MiniStepsSchema) GetNotifications() *NotificationTypes {
	if m == nil {
		return nil
	}
	return m.Notifications
}

func (m *MiniStepsSchema) GetWebhooks() *WebhookTypes {
	if m == nil {
		return nil
	}
	return m.Webhooks
}

func (m *MiniStepsSchema) GetExtraProperties() map[string]interface{} {
	return m.extraProperties
}

func (m *MiniStepsSchema) UnmarshalJSON(data []byte) error {
	type unmarshaler MiniStepsSchema
	var value unmarshaler
	if err := json.Unmarshal(data, &value); err != nil {
		return err
	}
	*m = MiniStepsSchema(value)
	extraProperties, err := internal.ExtractExtraProperties(data, *m)
	if err != nil {
		return err
	}
	m.extraProperties = extraProperties
	m.rawJSON = json.RawMessage(data)
	return nil
}

func (m *MiniStepsSchema) String() string {
	if len(m.rawJSON) > 0 {
		if value, err := internal.StringifyJSON(m.rawJSON); err == nil {
			return value
		}
	}
	if value, err := internal.StringifyJSON(m); err == nil {
		return value
	}
	return fmt.Sprintf("%#v", m)
}

type MountPoint struct {
	Source   string `json:"source" url:"source"`
	Target   string `json:"target" url:"target"`
	ReadOnly *bool  `json:"read_only,omitempty" url:"read_only,omitempty"`

	extraProperties map[string]interface{}
	rawJSON         json.RawMessage
}

func (m *MountPoint) GetSource() string {
	if m == nil {
		return ""
	}
	return m.Source
}

func (m *MountPoint) GetTarget() string {
	if m == nil {
		return ""
	}
	return m.Target
}

func (m *MountPoint) GetReadOnly() *bool {
	if m == nil {
		return nil
	}
	return m.ReadOnly
}

func (m *MountPoint) GetExtraProperties() map[string]interface{} {
	return m.extraProperties
}

func (m *MountPoint) UnmarshalJSON(data []byte) error {
	type unmarshaler MountPoint
	var value unmarshaler
	if err := json.Unmarshal(data, &value); err != nil {
		return err
	}
	*m = MountPoint(value)
	extraProperties, err := internal.ExtractExtraProperties(data, *m)
	if err != nil {
		return err
	}
	m.extraProperties = extraProperties
	m.rawJSON = json.RawMessage(data)
	return nil
}

func (m *MountPoint) String() string {
	if len(m.rawJSON) > 0 {
		if value, err := internal.StringifyJSON(m.rawJSON); err == nil {
			return value
		}
	}
	if value, err := internal.StringifyJSON(m); err == nil {
		return value
	}
	return fmt.Sprintf("%#v", m)
}

type NotificationEmailType struct {
	Email            map[string]interface{} `json:"email,omitempty" url:"email,omitempty"`
	ApprovalRequired []*Notifications       `json:"APPROVAL_REQUIRED,omitempty" url:"APPROVAL_REQUIRED,omitempty"`
	Cancelled        []*Notifications       `json:"CANCELLED,omitempty" url:"CANCELLED,omitempty"`
	Completed        []*Notifications       `json:"COMPLETED,omitempty" url:"COMPLETED,omitempty"`
	Errored          []*Notifications       `json:"ERRORED,omitempty" url:"ERRORED,omitempty"`
	DriftDetected    []*Notifications       `json:"DRIFT_DETECTED,omitempty" url:"DRIFT_DETECTED,omitempty"`

	extraProperties map[string]interface{}
	rawJSON         json.RawMessage
}

func (n *NotificationEmailType) GetEmail() map[string]interface{} {
	if n == nil {
		return nil
	}
	return n.Email
}

func (n *NotificationEmailType) GetApprovalRequired() []*Notifications {
	if n == nil {
		return nil
	}
	return n.ApprovalRequired
}

func (n *NotificationEmailType) GetCancelled() []*Notifications {
	if n == nil {
		return nil
	}
	return n.Cancelled
}

func (n *NotificationEmailType) GetCompleted() []*Notifications {
	if n == nil {
		return nil
	}
	return n.Completed
}

func (n *NotificationEmailType) GetErrored() []*Notifications {
	if n == nil {
		return nil
	}
	return n.Errored
}

func (n *NotificationEmailType) GetDriftDetected() []*Notifications {
	if n == nil {
		return nil
	}
	return n.DriftDetected
}

func (n *NotificationEmailType) GetExtraProperties() map[string]interface{} {
	return n.extraProperties
}

func (n *NotificationEmailType) UnmarshalJSON(data []byte) error {
	type unmarshaler NotificationEmailType
	var value unmarshaler
	if err := json.Unmarshal(data, &value); err != nil {
		return err
	}
	*n = NotificationEmailType(value)
	extraProperties, err := internal.ExtractExtraProperties(data, *n)
	if err != nil {
		return err
	}
	n.extraProperties = extraProperties
	n.rawJSON = json.RawMessage(data)
	return nil
}

func (n *NotificationEmailType) String() string {
	if len(n.rawJSON) > 0 {
		if value, err := internal.StringifyJSON(n.rawJSON); err == nil {
			return value
		}
	}
	if value, err := internal.StringifyJSON(n); err == nil {
		return value
	}
	return fmt.Sprintf("%#v", n)
}

type NotificationTypes struct {
	Email *NotificationEmailType `json:"email,omitempty" url:"email,omitempty"`

	extraProperties map[string]interface{}
	rawJSON         json.RawMessage
}

func (n *NotificationTypes) GetEmail() *NotificationEmailType {
	if n == nil {
		return nil
	}
	return n.Email
}

func (n *NotificationTypes) GetExtraProperties() map[string]interface{} {
	return n.extraProperties
}

func (n *NotificationTypes) UnmarshalJSON(data []byte) error {
	type unmarshaler NotificationTypes
	var value unmarshaler
	if err := json.Unmarshal(data, &value); err != nil {
		return err
	}
	*n = NotificationTypes(value)
	extraProperties, err := internal.ExtractExtraProperties(data, *n)
	if err != nil {
		return err
	}
	n.extraProperties = extraProperties
	n.rawJSON = json.RawMessage(data)
	return nil
}

func (n *NotificationTypes) String() string {
	if len(n.rawJSON) > 0 {
		if value, err := internal.StringifyJSON(n.rawJSON); err == nil {
			return value
		}
	}
	if value, err := internal.StringifyJSON(n); err == nil {
		return value
	}
	return fmt.Sprintf("%#v", n)
}

type Notifications struct {
	Recipients []string `json:"recipients,omitempty" url:"recipients,omitempty"`

	extraProperties map[string]interface{}
	rawJSON         json.RawMessage
}

func (n *Notifications) GetRecipients() []string {
	if n == nil {
		return nil
	}
	return n.Recipients
}

func (n *Notifications) GetExtraProperties() map[string]interface{} {
	return n.extraProperties
}

func (n *Notifications) UnmarshalJSON(data []byte) error {
	type unmarshaler Notifications
	var value unmarshaler
	if err := json.Unmarshal(data, &value); err != nil {
		return err
	}
	*n = Notifications(value)
	extraProperties, err := internal.ExtractExtraProperties(data, *n)
	if err != nil {
		return err
	}
	n.extraProperties = extraProperties
	n.rawJSON = json.RawMessage(data)
	return nil
}

func (n *Notifications) String() string {
	if len(n.rawJSON) > 0 {
		if value, err := internal.StringifyJSON(n.rawJSON); err == nil {
			return value
		}
	}
	if value, err := internal.StringifyJSON(n); err == nil {
		return value
	}
	return fmt.Sprintf("%#v", n)
}

type PatchedWorkflow struct {
	ResourceName                *string                     `json:"ResourceName,omitempty" url:"ResourceName,omitempty"`
	Description                 *string                     `json:"Description,omitempty" url:"Description,omitempty"`
	Tags                        []string                    `json:"Tags,omitempty" url:"Tags,omitempty"`
	IsActive                    *IsArchiveEnum              `json:"IsActive,omitempty" url:"IsActive,omitempty"`
	WfStepsConfig               []*WfStepsConfig            `json:"WfStepsConfig,omitempty" url:"WfStepsConfig,omitempty"`
	WfType                      *WfTypeEnum                 `json:"WfType,omitempty" url:"WfType,omitempty"`
	TerraformConfig             *TerraformConfig            `json:"TerraformConfig,omitempty" url:"TerraformConfig,omitempty"`
	EnvironmentVariables        []*EnvVars                  `json:"EnvironmentVariables,omitempty" url:"EnvironmentVariables,omitempty"`
	DeploymentPlatformConfig    []*DeploymentPlatformConfig `json:"DeploymentPlatformConfig,omitempty" url:"DeploymentPlatformConfig,omitempty"`
	VcsConfig                   *VcsConfig                  `json:"VCSConfig,omitempty" url:"VCSConfig,omitempty"`
	UserSchedules               []*UserSchedules            `json:"UserSchedules,omitempty" url:"UserSchedules,omitempty"`
	GitHubComSync               map[string]interface{}      `json:"GitHubComSync,omitempty" url:"GitHubComSync,omitempty"`
	MiniSteps                   *MiniStepsSchema            `json:"MiniSteps,omitempty" url:"MiniSteps,omitempty"`
	Approvers                   []string                    `json:"Approvers,omitempty" url:"Approvers,omitempty"`
	NumberOfApprovalsRequired   *int                        `json:"NumberOfApprovalsRequired,omitempty" url:"NumberOfApprovalsRequired,omitempty"`
	RunnerConstraints           *RunnerConstraints          `json:"RunnerConstraints,omitempty" url:"RunnerConstraints,omitempty"`
	UserJobCpu                  *int                        `json:"UserJobCPU,omitempty" url:"UserJobCPU,omitempty"`
	UserJobMemory               *int                        `json:"UserJobMemory,omitempty" url:"UserJobMemory,omitempty"`
	CacheConfig                 *CacheConfig                `json:"CacheConfig,omitempty" url:"CacheConfig,omitempty"`
	TfStateCleaned              map[string]interface{}      `json:"TfStateCleaned,omitempty" url:"TfStateCleaned,omitempty"`
	InfracostBreakdown          map[string]interface{}      `json:"InfracostBreakdown,omitempty" url:"InfracostBreakdown,omitempty"`
	PolicyEvalResults           map[string]interface{}      `json:"PolicyEvalResults,omitempty" url:"PolicyEvalResults,omitempty"`
	InfracostBreakdownPreApply  map[string]interface{}      `json:"InfracostBreakdownPreApply,omitempty" url:"InfracostBreakdownPreApply,omitempty"`
	InfracostBreakdownPostApply map[string]interface{}      `json:"InfracostBreakdownPostApply,omitempty" url:"InfracostBreakdownPostApply,omitempty"`
	TfDrift                     map[string]interface{}      `json:"TfDrift,omitempty" url:"TfDrift,omitempty"`
	CfStateCleaned              map[string]interface{}      `json:"CfStateCleaned,omitempty" url:"CfStateCleaned,omitempty"`
	CfStackPlan                 map[string]interface{}      `json:"CfStackPlan,omitempty" url:"CfStackPlan,omitempty"`
	CfDrift                     map[string]interface{}      `json:"CfDrift,omitempty" url:"CfDrift,omitempty"`
	K8SResources                map[string]interface{}      `json:"K8sResources,omitempty" url:"K8sResources,omitempty"`
	K8SDrift                    map[string]interface{}      `json:"K8sDrift,omitempty" url:"K8sDrift,omitempty"`
	TerragruntDrift             map[string]interface{}      `json:"TerragruntDrift,omitempty" url:"TerragruntDrift,omitempty"`
	AnsibleOutputs              map[string]interface{}      `json:"AnsibleOutputs,omitempty" url:"AnsibleOutputs,omitempty"`
	AnsiblePlan                 map[string]interface{}      `json:"AnsiblePlan,omitempty" url:"AnsiblePlan,omitempty"`
	AnsibleDrift                map[string]interface{}      `json:"AnsibleDrift,omitempty" url:"AnsibleDrift,omitempty"`
	BicepResources              map[string]interface{}      `json:"BicepResources,omitempty" url:"BicepResources,omitempty"`
	SgCustomWorkflowRunFacts    map[string]interface{}      `json:"SGCustomWorkflowRunFacts,omitempty" url:"SGCustomWorkflowRunFacts,omitempty"`
	// Contextual tags to give context to your tags
	ContextTags map[string]*string `json:"ContextTags,omitempty" url:"ContextTags,omitempty"`

	extraProperties map[string]interface{}
	rawJSON         json.RawMessage
}

func (p *PatchedWorkflow) GetResourceName() *string {
	if p == nil {
		return nil
	}
	return p.ResourceName
}

func (p *PatchedWorkflow) GetDescription() *string {
	if p == nil {
		return nil
	}
	return p.Description
}

func (p *PatchedWorkflow) GetTags() []string {
	if p == nil {
		return nil
	}
	return p.Tags
}

func (p *PatchedWorkflow) GetIsActive() *IsArchiveEnum {
	if p == nil {
		return nil
	}
	return p.IsActive
}

func (p *PatchedWorkflow) GetWfStepsConfig() []*WfStepsConfig {
	if p == nil {
		return nil
	}
	return p.WfStepsConfig
}

func (p *PatchedWorkflow) GetWfType() *WfTypeEnum {
	if p == nil {
		return nil
	}
	return p.WfType
}

func (p *PatchedWorkflow) GetTerraformConfig() *TerraformConfig {
	if p == nil {
		return nil
	}
	return p.TerraformConfig
}

func (p *PatchedWorkflow) GetEnvironmentVariables() []*EnvVars {
	if p == nil {
		return nil
	}
	return p.EnvironmentVariables
}

func (p *PatchedWorkflow) GetDeploymentPlatformConfig() []*DeploymentPlatformConfig {
	if p == nil {
		return nil
	}
	return p.DeploymentPlatformConfig
}

func (p *PatchedWorkflow) GetVcsConfig() *VcsConfig {
	if p == nil {
		return nil
	}
	return p.VcsConfig
}

func (p *PatchedWorkflow) GetUserSchedules() []*UserSchedules {
	if p == nil {
		return nil
	}
	return p.UserSchedules
}

func (p *PatchedWorkflow) GetGitHubComSync() map[string]interface{} {
	if p == nil {
		return nil
	}
	return p.GitHubComSync
}

func (p *PatchedWorkflow) GetMiniSteps() *MiniStepsSchema {
	if p == nil {
		return nil
	}
	return p.MiniSteps
}

func (p *PatchedWorkflow) GetApprovers() []string {
	if p == nil {
		return nil
	}
	return p.Approvers
}

func (p *PatchedWorkflow) GetNumberOfApprovalsRequired() *int {
	if p == nil {
		return nil
	}
	return p.NumberOfApprovalsRequired
}

func (p *PatchedWorkflow) GetRunnerConstraints() *RunnerConstraints {
	if p == nil {
		return nil
	}
	return p.RunnerConstraints
}

func (p *PatchedWorkflow) GetUserJobCpu() *int {
	if p == nil {
		return nil
	}
	return p.UserJobCpu
}

func (p *PatchedWorkflow) GetUserJobMemory() *int {
	if p == nil {
		return nil
	}
	return p.UserJobMemory
}

func (p *PatchedWorkflow) GetCacheConfig() *CacheConfig {
	if p == nil {
		return nil
	}
	return p.CacheConfig
}

func (p *PatchedWorkflow) GetTfStateCleaned() map[string]interface{} {
	if p == nil {
		return nil
	}
	return p.TfStateCleaned
}

func (p *PatchedWorkflow) GetInfracostBreakdown() map[string]interface{} {
	if p == nil {
		return nil
	}
	return p.InfracostBreakdown
}

func (p *PatchedWorkflow) GetPolicyEvalResults() map[string]interface{} {
	if p == nil {
		return nil
	}
	return p.PolicyEvalResults
}

func (p *PatchedWorkflow) GetInfracostBreakdownPreApply() map[string]interface{} {
	if p == nil {
		return nil
	}
	return p.InfracostBreakdownPreApply
}

func (p *PatchedWorkflow) GetInfracostBreakdownPostApply() map[string]interface{} {
	if p == nil {
		return nil
	}
	return p.InfracostBreakdownPostApply
}

func (p *PatchedWorkflow) GetTfDrift() map[string]interface{} {
	if p == nil {
		return nil
	}
	return p.TfDrift
}

func (p *PatchedWorkflow) GetCfStateCleaned() map[string]interface{} {
	if p == nil {
		return nil
	}
	return p.CfStateCleaned
}

func (p *PatchedWorkflow) GetCfStackPlan() map[string]interface{} {
	if p == nil {
		return nil
	}
	return p.CfStackPlan
}

func (p *PatchedWorkflow) GetCfDrift() map[string]interface{} {
	if p == nil {
		return nil
	}
	return p.CfDrift
}

func (p *PatchedWorkflow) GetK8SResources() map[string]interface{} {
	if p == nil {
		return nil
	}
	return p.K8SResources
}

func (p *PatchedWorkflow) GetK8SDrift() map[string]interface{} {
	if p == nil {
		return nil
	}
	return p.K8SDrift
}

func (p *PatchedWorkflow) GetTerragruntDrift() map[string]interface{} {
	if p == nil {
		return nil
	}
	return p.TerragruntDrift
}

func (p *PatchedWorkflow) GetAnsibleOutputs() map[string]interface{} {
	if p == nil {
		return nil
	}
	return p.AnsibleOutputs
}

func (p *PatchedWorkflow) GetAnsiblePlan() map[string]interface{} {
	if p == nil {
		return nil
	}
	return p.AnsiblePlan
}

func (p *PatchedWorkflow) GetAnsibleDrift() map[string]interface{} {
	if p == nil {
		return nil
	}
	return p.AnsibleDrift
}

func (p *PatchedWorkflow) GetBicepResources() map[string]interface{} {
	if p == nil {
		return nil
	}
	return p.BicepResources
}

func (p *PatchedWorkflow) GetSgCustomWorkflowRunFacts() map[string]interface{} {
	if p == nil {
		return nil
	}
	return p.SgCustomWorkflowRunFacts
}

func (p *PatchedWorkflow) GetContextTags() map[string]*string {
	if p == nil {
		return nil
	}
	return p.ContextTags
}

func (p *PatchedWorkflow) GetExtraProperties() map[string]interface{} {
	return p.extraProperties
}

func (p *PatchedWorkflow) UnmarshalJSON(data []byte) error {
	type unmarshaler PatchedWorkflow
	var value unmarshaler
	if err := json.Unmarshal(data, &value); err != nil {
		return err
	}
	*p = PatchedWorkflow(value)
	extraProperties, err := internal.ExtractExtraProperties(data, *p)
	if err != nil {
		return err
	}
	p.extraProperties = extraProperties
	p.rawJSON = json.RawMessage(data)
	return nil
}

func (p *PatchedWorkflow) String() string {
	if len(p.rawJSON) > 0 {
		if value, err := internal.StringifyJSON(p.rawJSON); err == nil {
			return value
		}
	}
	if value, err := internal.StringifyJSON(p); err == nil {
		return value
	}
	return fmt.Sprintf("%#v", p)
}

// * `PULL_PUSH` - PULL_PUSH
// * `PULL` - PULL
// * `PUSH` - PUSH
type PolicyEnum string

const (
	PolicyEnumPullPush PolicyEnum = "PULL_PUSH"
	PolicyEnumPull     PolicyEnum = "PULL"
	PolicyEnumPush     PolicyEnum = "PUSH"
)

func NewPolicyEnumFromString(s string) (PolicyEnum, error) {
	switch s {
	case "PULL_PUSH":
		return PolicyEnumPullPush, nil
	case "PULL":
		return PolicyEnumPull, nil
	case "PUSH":
		return PolicyEnumPush, nil
	}
	var t PolicyEnum
	return "", fmt.Errorf("%s is not a valid %T", s, t)
}

func (p PolicyEnum) Ptr() *PolicyEnum {
	return &p
}

// * `GENERAL` - GENERAL
// * `FILTER.INSIGHT` - FILTER.INSIGHT
type PolicyTypeEnum string

const (
	PolicyTypeEnumGeneral       PolicyTypeEnum = "GENERAL"
	PolicyTypeEnumFilterInsight PolicyTypeEnum = "FILTER.INSIGHT"
)

func NewPolicyTypeEnumFromString(s string) (PolicyTypeEnum, error) {
	switch s {
	case "GENERAL":
		return PolicyTypeEnumGeneral, nil
	case "FILTER.INSIGHT":
		return PolicyTypeEnumFilterInsight, nil
	}
	var t PolicyTypeEnum
	return "", fmt.Errorf("%s is not a valid %T", s, t)
}

func (p PolicyTypeEnum) Ptr() *PolicyTypeEnum {
	return &p
}

type RunnerConstraints struct {
	Type      RunnerConstraintsTypeEnum `json:"type" url:"type"`
	Names     []string                  `json:"names,omitempty" url:"names,omitempty"`
	Selectors []string                  `json:"selectors,omitempty" url:"selectors,omitempty"`

	extraProperties map[string]interface{}
	rawJSON         json.RawMessage
}

func (r *RunnerConstraints) GetType() RunnerConstraintsTypeEnum {
	if r == nil {
		return ""
	}
	return r.Type
}

func (r *RunnerConstraints) GetNames() []string {
	if r == nil {
		return nil
	}
	return r.Names
}

func (r *RunnerConstraints) GetSelectors() []string {
	if r == nil {
		return nil
	}
	return r.Selectors
}

func (r *RunnerConstraints) GetExtraProperties() map[string]interface{} {
	return r.extraProperties
}

func (r *RunnerConstraints) UnmarshalJSON(data []byte) error {
	type unmarshaler RunnerConstraints
	var value unmarshaler
	if err := json.Unmarshal(data, &value); err != nil {
		return err
	}
	*r = RunnerConstraints(value)
	extraProperties, err := internal.ExtractExtraProperties(data, *r)
	if err != nil {
		return err
	}
	r.extraProperties = extraProperties
	r.rawJSON = json.RawMessage(data)
	return nil
}

func (r *RunnerConstraints) String() string {
	if len(r.rawJSON) > 0 {
		if value, err := internal.StringifyJSON(r.rawJSON); err == nil {
			return value
		}
	}
	if value, err := internal.StringifyJSON(r); err == nil {
		return value
	}
	return fmt.Sprintf("%#v", r)
}

// * `private` - private
// * `shared` - shared
type RunnerConstraintsTypeEnum string

const (
	RunnerConstraintsTypeEnumPrivate RunnerConstraintsTypeEnum = "private"
	RunnerConstraintsTypeEnumShared  RunnerConstraintsTypeEnum = "shared"
)

func NewRunnerConstraintsTypeEnumFromString(s string) (RunnerConstraintsTypeEnum, error) {
	switch s {
	case "private":
		return RunnerConstraintsTypeEnumPrivate, nil
	case "shared":
		return RunnerConstraintsTypeEnumShared, nil
	}
	var t RunnerConstraintsTypeEnum
	return "", fmt.Errorf("%s is not a valid %T", s, t)
}

func (r RunnerConstraintsTypeEnum) Ptr() *RunnerConstraintsTypeEnum {
	return &r
}

type RuntimeSource struct {
	Config               *RuntimeSourceConfig                   `json:"config,omitempty" url:"config,omitempty"`
	SourceConfigDestKind *RuntimeSourceSourceConfigDestKindEnum `json:"sourceConfigDestKind,omitempty" url:"sourceConfigDestKind,omitempty"`

	extraProperties map[string]interface{}
	rawJSON         json.RawMessage
}

func (r *RuntimeSource) GetConfig() *RuntimeSourceConfig {
	if r == nil {
		return nil
	}
	return r.Config
}

func (r *RuntimeSource) GetExtraProperties() map[string]interface{} {
	return r.extraProperties
}

func (r *RuntimeSource) UnmarshalJSON(data []byte) error {
	type unmarshaler RuntimeSource
	var value unmarshaler
	if err := json.Unmarshal(data, &value); err != nil {
		return err
	}
	*r = RuntimeSource(value)
	extraProperties, err := internal.ExtractExtraProperties(data, *r)
	if err != nil {
		return err
	}
	r.extraProperties = extraProperties
	r.rawJSON = json.RawMessage(data)
	return nil
}

func (r *RuntimeSource) String() string {
	if len(r.rawJSON) > 0 {
		if value, err := internal.StringifyJSON(r.rawJSON); err == nil {
			return value
		}
	}
	if value, err := internal.StringifyJSON(r); err == nil {
		return value
	}
	return fmt.Sprintf("%#v", r)
}

type RuntimeSourceConfig struct {
	IsPrivate               *bool   `json:"isPrivate,omitempty" url:"isPrivate,omitempty"`
	Auth                    *string `json:"auth,omitempty" url:"auth,omitempty"`
	WorkingDir              *string `json:"workingDir,omitempty" url:"workingDir,omitempty"`
	Ref                     *string `json:"ref,omitempty" url:"ref,omitempty"`
	Repo                    *string `json:"repo,omitempty" url:"repo,omitempty"`
	DockerImage             *string `json:"dockerImage,omitempty" url:"dockerImage,omitempty"`
	DockerRegistryUsername  *string `json:"dockerRegistryUsername,omitempty" url:"dockerRegistryUsername,omitempty"`
	LocalWorkspaceDir       *string `json:"localWorkspaceDir,omitempty" url:"localWorkspaceDir,omitempty"`
	IncludeSubModule        *bool   `json:"includeSubModule,omitempty" url:"includeSubModule,omitempty"`
	GitSparseCheckoutConfig *string `json:"gitSparseCheckoutConfig,omitempty" url:"gitSparseCheckoutConfig,omitempty"`
	GitCoreAutoCrlf         *bool   `json:"gitCoreAutoCRLF,omitempty" url:"gitCoreAutoCRLF,omitempty"`

	extraProperties map[string]interface{}
	rawJSON         json.RawMessage
}

func (r *RuntimeSourceConfig) GetIsPrivate() *bool {
	if r == nil {
		return nil
	}
	return r.IsPrivate
}

func (r *RuntimeSourceConfig) GetAuth() *string {
	if r == nil {
		return nil
	}
	return r.Auth
}

func (r *RuntimeSourceConfig) GetWorkingDir() *string {
	if r == nil {
		return nil
	}
	return r.WorkingDir
}

func (r *RuntimeSourceConfig) GetRef() *string {
	if r == nil {
		return nil
	}
	return r.Ref
}

func (r *RuntimeSourceConfig) GetRepo() *string {
	if r == nil {
		return nil
	}
	return r.Repo
}

func (r *RuntimeSourceConfig) GetDockerImage() *string {
	if r == nil {
		return nil
	}
	return r.DockerImage
}

func (r *RuntimeSourceConfig) GetDockerRegistryUsername() *string {
	if r == nil {
		return nil
	}
	return r.DockerRegistryUsername
}

func (r *RuntimeSourceConfig) GetLocalWorkspaceDir() *string {
	if r == nil {
		return nil
	}
	return r.LocalWorkspaceDir
}

func (r *RuntimeSourceConfig) GetIncludeSubModule() *bool {
	if r == nil {
		return nil
	}
	return r.IncludeSubModule
}

func (r *RuntimeSourceConfig) GetGitSparseCheckoutConfig() *string {
	if r == nil {
		return nil
	}
	return r.GitSparseCheckoutConfig
}

func (r *RuntimeSourceConfig) GetGitCoreAutoCrlf() *bool {
	if r == nil {
		return nil
	}
	return r.GitCoreAutoCrlf
}

func (r *RuntimeSourceConfig) GetExtraProperties() map[string]interface{} {
	return r.extraProperties
}

func (r *RuntimeSourceConfig) UnmarshalJSON(data []byte) error {
	type unmarshaler RuntimeSourceConfig
	var value unmarshaler
	if err := json.Unmarshal(data, &value); err != nil {
		return err
	}
	*r = RuntimeSourceConfig(value)
	extraProperties, err := internal.ExtractExtraProperties(data, *r)
	if err != nil {
		return err
	}
	r.extraProperties = extraProperties
	r.rawJSON = json.RawMessage(data)
	return nil
}

func (r *RuntimeSourceConfig) String() string {
	if len(r.rawJSON) > 0 {
		if value, err := internal.StringifyJSON(r.rawJSON); err == nil {
			return value
		}
	}
	if value, err := internal.StringifyJSON(r); err == nil {
		return value
	}
	return fmt.Sprintf("%#v", r)
}

// * `CONTAINER_REGISTRY` - CONTAINER_REGISTRY
type RuntimeSourceSourceConfigDestKindEnum = string

type StackAction struct {
	ActionType string `json:"ActionType" url:"ActionType"`

	extraProperties map[string]interface{}
	rawJSON         json.RawMessage
}

func (s *StackAction) GetActionType() string {
	if s == nil {
		return ""
	}
	return s.ActionType
}

func (s *StackAction) GetExtraProperties() map[string]interface{} {
	return s.extraProperties
}

func (s *StackAction) UnmarshalJSON(data []byte) error {
	type unmarshaler StackAction
	var value unmarshaler
	if err := json.Unmarshal(data, &value); err != nil {
		return err
	}
	*s = StackAction(value)
	extraProperties, err := internal.ExtractExtraProperties(data, *s)
	if err != nil {
		return err
	}
	s.extraProperties = extraProperties
	s.rawJSON = json.RawMessage(data)
	return nil
}

func (s *StackAction) String() string {
	if len(s.rawJSON) > 0 {
		if value, err := internal.StringifyJSON(s.rawJSON); err == nil {
			return value
		}
	}
	if value, err := internal.StringifyJSON(s); err == nil {
		return value
	}
	return fmt.Sprintf("%#v", s)
}

type StackUserSchedules struct {
	Name   *string      `json:"name,omitempty" url:"name,omitempty"`
	Desc   *string      `json:"desc,omitempty" url:"desc,omitempty"`
	Cron   string       `json:"cron" url:"cron"`
	State  StateEnum    `json:"state" url:"state"`
	Inputs *StackAction `json:"inputs,omitempty" url:"inputs,omitempty"`

	extraProperties map[string]interface{}
	rawJSON         json.RawMessage
}

func (s *StackUserSchedules) GetName() *string {
	if s == nil {
		return nil
	}
	return s.Name
}

func (s *StackUserSchedules) GetDesc() *string {
	if s == nil {
		return nil
	}
	return s.Desc
}

func (s *StackUserSchedules) GetCron() string {
	if s == nil {
		return ""
	}
	return s.Cron
}

func (s *StackUserSchedules) GetState() StateEnum {
	if s == nil {
		return ""
	}
	return s.State
}

func (s *StackUserSchedules) GetInputs() *StackAction {
	if s == nil {
		return nil
	}
	return s.Inputs
}

func (s *StackUserSchedules) GetExtraProperties() map[string]interface{} {
	return s.extraProperties
}

func (s *StackUserSchedules) UnmarshalJSON(data []byte) error {
	type unmarshaler StackUserSchedules
	var value unmarshaler
	if err := json.Unmarshal(data, &value); err != nil {
		return err
	}
	*s = StackUserSchedules(value)
	extraProperties, err := internal.ExtractExtraProperties(data, *s)
	if err != nil {
		return err
	}
	s.extraProperties = extraProperties
	s.rawJSON = json.RawMessage(data)
	return nil
}

func (s *StackUserSchedules) String() string {
	if len(s.rawJSON) > 0 {
		if value, err := internal.StringifyJSON(s.rawJSON); err == nil {
			return value
		}
	}
	if value, err := internal.StringifyJSON(s); err == nil {
		return value
	}
	return fmt.Sprintf("%#v", s)
}

// * `ENABLED` - ENABLED
// * `DISABLED` - DISABLED
type StateEnum string

const (
	StateEnumEnabled  StateEnum = "ENABLED"
	StateEnumDisabled StateEnum = "DISABLED"
)

func NewStateEnumFromString(s string) (StateEnum, error) {
	switch s {
	case "ENABLED":
		return StateEnumEnabled, nil
	case "DISABLED":
		return StateEnumDisabled, nil
	}
	var t StateEnum
	return "", fmt.Errorf("%s is not a valid %T", s, t)
}

func (s StateEnum) Ptr() *StateEnum {
	return &s
}

// * `IAC` - IAC
// * `IAC_GROUP` - IAC_GROUP
// * `WORKFLOW_STEP` - WORKFLOW_STEP
// * `IAC_POLICY` - IAC_POLICY
// * `WORKFLOW_STEP_POLICY` - WORKFLOW_STEP_POLICY
// * `REACTIVE_POLICY` - REACTIVE_POLICY
type TemplateTypeEnum string

const (
	TemplateTypeEnumIac                TemplateTypeEnum = "IAC"
	TemplateTypeEnumIacGroup           TemplateTypeEnum = "IAC_GROUP"
	TemplateTypeEnumWorkflowStep       TemplateTypeEnum = "WORKFLOW_STEP"
	TemplateTypeEnumIacPolicy          TemplateTypeEnum = "IAC_POLICY"
	TemplateTypeEnumWorkflowStepPolicy TemplateTypeEnum = "WORKFLOW_STEP_POLICY"
	TemplateTypeEnumReactivePolicy     TemplateTypeEnum = "REACTIVE_POLICY"
)

func NewTemplateTypeEnumFromString(s string) (TemplateTypeEnum, error) {
	switch s {
	case "IAC":
		return TemplateTypeEnumIac, nil
	case "IAC_GROUP":
		return TemplateTypeEnumIacGroup, nil
	case "WORKFLOW_STEP":
		return TemplateTypeEnumWorkflowStep, nil
	case "IAC_POLICY":
		return TemplateTypeEnumIacPolicy, nil
	case "WORKFLOW_STEP_POLICY":
		return TemplateTypeEnumWorkflowStepPolicy, nil
	case "REACTIVE_POLICY":
		return TemplateTypeEnumReactivePolicy, nil
	}
	var t TemplateTypeEnum
	return "", fmt.Errorf("%s is not a valid %T", s, t)
}

func (t TemplateTypeEnum) Ptr() *TemplateTypeEnum {
	return &t
}

type TemplateWorkflow struct {
	ResourceName                *string                     `json:"ResourceName,omitempty" url:"ResourceName,omitempty"`
	Description                 *string                     `json:"Description,omitempty" url:"Description,omitempty"`
	Tags                        []string                    `json:"Tags,omitempty" url:"Tags,omitempty"`
	IsActive                    *IsArchiveEnum              `json:"IsActive,omitempty" url:"IsActive,omitempty"`
	WfStepsConfig               []*WfStepsConfig            `json:"WfStepsConfig,omitempty" url:"WfStepsConfig,omitempty"`
	WfType                      *WfTypeEnum                 `json:"WfType,omitempty" url:"WfType,omitempty"`
	TerraformConfig             *TerraformConfig            `json:"TerraformConfig,omitempty" url:"TerraformConfig,omitempty"`
	EnvironmentVariables        []*EnvVars                  `json:"EnvironmentVariables,omitempty" url:"EnvironmentVariables,omitempty"`
	DeploymentPlatformConfig    []*DeploymentPlatformConfig `json:"DeploymentPlatformConfig,omitempty" url:"DeploymentPlatformConfig,omitempty"`
	VcsConfig                   *VcsConfig                  `json:"VCSConfig,omitempty" url:"VCSConfig,omitempty"`
	UserSchedules               []*UserSchedules            `json:"UserSchedules,omitempty" url:"UserSchedules,omitempty"`
	GitHubComSync               map[string]interface{}      `json:"GitHubComSync,omitempty" url:"GitHubComSync,omitempty"`
	MiniSteps                   *MiniStepsSchema            `json:"MiniSteps,omitempty" url:"MiniSteps,omitempty"`
	Approvers                   []string                    `json:"Approvers,omitempty" url:"Approvers,omitempty"`
	NumberOfApprovalsRequired   *int                        `json:"NumberOfApprovalsRequired,omitempty" url:"NumberOfApprovalsRequired,omitempty"`
	RunnerConstraints           *RunnerConstraints          `json:"RunnerConstraints,omitempty" url:"RunnerConstraints,omitempty"`
	UserJobCpu                  *int                        `json:"UserJobCPU,omitempty" url:"UserJobCPU,omitempty"`
	UserJobMemory               *int                        `json:"UserJobMemory,omitempty" url:"UserJobMemory,omitempty"`
	CacheConfig                 *CacheConfig                `json:"CacheConfig,omitempty" url:"CacheConfig,omitempty"`
	TfStateCleaned              map[string]interface{}      `json:"TfStateCleaned,omitempty" url:"TfStateCleaned,omitempty"`
	InfracostBreakdown          map[string]interface{}      `json:"InfracostBreakdown,omitempty" url:"InfracostBreakdown,omitempty"`
	PolicyEvalResults           map[string]interface{}      `json:"PolicyEvalResults,omitempty" url:"PolicyEvalResults,omitempty"`
	InfracostBreakdownPreApply  map[string]interface{}      `json:"InfracostBreakdownPreApply,omitempty" url:"InfracostBreakdownPreApply,omitempty"`
	InfracostBreakdownPostApply map[string]interface{}      `json:"InfracostBreakdownPostApply,omitempty" url:"InfracostBreakdownPostApply,omitempty"`
	TfDrift                     map[string]interface{}      `json:"TfDrift,omitempty" url:"TfDrift,omitempty"`
	CfStateCleaned              map[string]interface{}      `json:"CfStateCleaned,omitempty" url:"CfStateCleaned,omitempty"`
	CfStackPlan                 map[string]interface{}      `json:"CfStackPlan,omitempty" url:"CfStackPlan,omitempty"`
	CfDrift                     map[string]interface{}      `json:"CfDrift,omitempty" url:"CfDrift,omitempty"`
	K8SResources                map[string]interface{}      `json:"K8sResources,omitempty" url:"K8sResources,omitempty"`
	K8SDrift                    map[string]interface{}      `json:"K8sDrift,omitempty" url:"K8sDrift,omitempty"`
	TerragruntDrift             map[string]interface{}      `json:"TerragruntDrift,omitempty" url:"TerragruntDrift,omitempty"`
	AnsibleOutputs              map[string]interface{}      `json:"AnsibleOutputs,omitempty" url:"AnsibleOutputs,omitempty"`
	AnsiblePlan                 map[string]interface{}      `json:"AnsiblePlan,omitempty" url:"AnsiblePlan,omitempty"`
	AnsibleDrift                map[string]interface{}      `json:"AnsibleDrift,omitempty" url:"AnsibleDrift,omitempty"`
	BicepResources              map[string]interface{}      `json:"BicepResources,omitempty" url:"BicepResources,omitempty"`
	SgCustomWorkflowRunFacts    map[string]interface{}      `json:"SGCustomWorkflowRunFacts,omitempty" url:"SGCustomWorkflowRunFacts,omitempty"`
	// Contextual tags to give context to your tags
	ContextTags  map[string]*string     `json:"ContextTags,omitempty" url:"ContextTags,omitempty"`
	Id           *string                `json:"id,omitempty" url:"id,omitempty"`
	TemplateId   *string                `json:"templateId,omitempty" url:"templateId,omitempty"`
	IacInputData *TemplatesIacInputData `json:"iacInputData,omitempty" url:"iacInputData,omitempty"`
	InputSchemas []*InputSchemas        `json:"inputSchemas,omitempty" url:"inputSchemas,omitempty"`

	extraProperties map[string]interface{}
	rawJSON         json.RawMessage
}

func (t *TemplateWorkflow) GetResourceName() *string {
	if t == nil {
		return nil
	}
	return t.ResourceName
}

func (t *TemplateWorkflow) GetDescription() *string {
	if t == nil {
		return nil
	}
	return t.Description
}

func (t *TemplateWorkflow) GetTags() []string {
	if t == nil {
		return nil
	}
	return t.Tags
}

func (t *TemplateWorkflow) GetIsActive() *IsArchiveEnum {
	if t == nil {
		return nil
	}
	return t.IsActive
}

func (t *TemplateWorkflow) GetWfStepsConfig() []*WfStepsConfig {
	if t == nil {
		return nil
	}
	return t.WfStepsConfig
}

func (t *TemplateWorkflow) GetWfType() *WfTypeEnum {
	if t == nil {
		return nil
	}
	return t.WfType
}

func (t *TemplateWorkflow) GetTerraformConfig() *TerraformConfig {
	if t == nil {
		return nil
	}
	return t.TerraformConfig
}

func (t *TemplateWorkflow) GetEnvironmentVariables() []*EnvVars {
	if t == nil {
		return nil
	}
	return t.EnvironmentVariables
}

func (t *TemplateWorkflow) GetDeploymentPlatformConfig() []*DeploymentPlatformConfig {
	if t == nil {
		return nil
	}
	return t.DeploymentPlatformConfig
}

func (t *TemplateWorkflow) GetVcsConfig() *VcsConfig {
	if t == nil {
		return nil
	}
	return t.VcsConfig
}

func (t *TemplateWorkflow) GetUserSchedules() []*UserSchedules {
	if t == nil {
		return nil
	}
	return t.UserSchedules
}

func (t *TemplateWorkflow) GetGitHubComSync() map[string]interface{} {
	if t == nil {
		return nil
	}
	return t.GitHubComSync
}

func (t *TemplateWorkflow) GetMiniSteps() *MiniStepsSchema {
	if t == nil {
		return nil
	}
	return t.MiniSteps
}

func (t *TemplateWorkflow) GetApprovers() []string {
	if t == nil {
		return nil
	}
	return t.Approvers
}

func (t *TemplateWorkflow) GetNumberOfApprovalsRequired() *int {
	if t == nil {
		return nil
	}
	return t.NumberOfApprovalsRequired
}

func (t *TemplateWorkflow) GetRunnerConstraints() *RunnerConstraints {
	if t == nil {
		return nil
	}
	return t.RunnerConstraints
}

func (t *TemplateWorkflow) GetUserJobCpu() *int {
	if t == nil {
		return nil
	}
	return t.UserJobCpu
}

func (t *TemplateWorkflow) GetUserJobMemory() *int {
	if t == nil {
		return nil
	}
	return t.UserJobMemory
}

func (t *TemplateWorkflow) GetCacheConfig() *CacheConfig {
	if t == nil {
		return nil
	}
	return t.CacheConfig
}

func (t *TemplateWorkflow) GetTfStateCleaned() map[string]interface{} {
	if t == nil {
		return nil
	}
	return t.TfStateCleaned
}

func (t *TemplateWorkflow) GetInfracostBreakdown() map[string]interface{} {
	if t == nil {
		return nil
	}
	return t.InfracostBreakdown
}

func (t *TemplateWorkflow) GetPolicyEvalResults() map[string]interface{} {
	if t == nil {
		return nil
	}
	return t.PolicyEvalResults
}

func (t *TemplateWorkflow) GetInfracostBreakdownPreApply() map[string]interface{} {
	if t == nil {
		return nil
	}
	return t.InfracostBreakdownPreApply
}

func (t *TemplateWorkflow) GetInfracostBreakdownPostApply() map[string]interface{} {
	if t == nil {
		return nil
	}
	return t.InfracostBreakdownPostApply
}

func (t *TemplateWorkflow) GetTfDrift() map[string]interface{} {
	if t == nil {
		return nil
	}
	return t.TfDrift
}

func (t *TemplateWorkflow) GetCfStateCleaned() map[string]interface{} {
	if t == nil {
		return nil
	}
	return t.CfStateCleaned
}

func (t *TemplateWorkflow) GetCfStackPlan() map[string]interface{} {
	if t == nil {
		return nil
	}
	return t.CfStackPlan
}

func (t *TemplateWorkflow) GetCfDrift() map[string]interface{} {
	if t == nil {
		return nil
	}
	return t.CfDrift
}

func (t *TemplateWorkflow) GetK8SResources() map[string]interface{} {
	if t == nil {
		return nil
	}
	return t.K8SResources
}

func (t *TemplateWorkflow) GetK8SDrift() map[string]interface{} {
	if t == nil {
		return nil
	}
	return t.K8SDrift
}

func (t *TemplateWorkflow) GetTerragruntDrift() map[string]interface{} {
	if t == nil {
		return nil
	}
	return t.TerragruntDrift
}

func (t *TemplateWorkflow) GetAnsibleOutputs() map[string]interface{} {
	if t == nil {
		return nil
	}
	return t.AnsibleOutputs
}

func (t *TemplateWorkflow) GetAnsiblePlan() map[string]interface{} {
	if t == nil {
		return nil
	}
	return t.AnsiblePlan
}

func (t *TemplateWorkflow) GetAnsibleDrift() map[string]interface{} {
	if t == nil {
		return nil
	}
	return t.AnsibleDrift
}

func (t *TemplateWorkflow) GetBicepResources() map[string]interface{} {
	if t == nil {
		return nil
	}
	return t.BicepResources
}

func (t *TemplateWorkflow) GetSgCustomWorkflowRunFacts() map[string]interface{} {
	if t == nil {
		return nil
	}
	return t.SgCustomWorkflowRunFacts
}

func (t *TemplateWorkflow) GetContextTags() map[string]*string {
	if t == nil {
		return nil
	}
	return t.ContextTags
}

func (t *TemplateWorkflow) GetId() *string {
	if t == nil {
		return nil
	}
	return t.Id
}

func (t *TemplateWorkflow) GetTemplateId() *string {
	if t == nil {
		return nil
	}
	return t.TemplateId
}

func (t *TemplateWorkflow) GetIacInputData() *TemplatesIacInputData {
	if t == nil {
		return nil
	}
	return t.IacInputData
}

func (t *TemplateWorkflow) GetInputSchemas() []*InputSchemas {
	if t == nil {
		return nil
	}
	return t.InputSchemas
}

func (t *TemplateWorkflow) GetExtraProperties() map[string]interface{} {
	return t.extraProperties
}

func (t *TemplateWorkflow) UnmarshalJSON(data []byte) error {
	type unmarshaler TemplateWorkflow
	var value unmarshaler
	if err := json.Unmarshal(data, &value); err != nil {
		return err
	}
	*t = TemplateWorkflow(value)
	extraProperties, err := internal.ExtractExtraProperties(data, *t)
	if err != nil {
		return err
	}
	t.extraProperties = extraProperties
	t.rawJSON = json.RawMessage(data)
	return nil
}

func (t *TemplateWorkflow) String() string {
	if len(t.rawJSON) > 0 {
		if value, err := internal.StringifyJSON(t.rawJSON); err == nil {
			return value
		}
	}
	if value, err := internal.StringifyJSON(t); err == nil {
		return value
	}
	return fmt.Sprintf("%#v", t)
}

type TemplatesConfig struct {
	Actions         map[string]interface{} `json:"actions,omitempty" url:"actions,omitempty"`
	Templates       []*TemplateWorkflow    `json:"templates,omitempty" url:"templates,omitempty"`
	TemplateGroupId *string                `json:"templateGroupId,omitempty" url:"templateGroupId,omitempty"`

	extraProperties map[string]interface{}
	rawJSON         json.RawMessage
}

func (t *TemplatesConfig) GetActions() map[string]interface{} {
	if t == nil {
		return nil
	}
	return t.Actions
}

func (t *TemplatesConfig) GetTemplates() []*TemplateWorkflow {
	if t == nil {
		return nil
	}
	return t.Templates
}

func (t *TemplatesConfig) GetTemplateGroupId() *string {
	if t == nil {
		return nil
	}
	return t.TemplateGroupId
}

func (t *TemplatesConfig) GetExtraProperties() map[string]interface{} {
	return t.extraProperties
}

func (t *TemplatesConfig) UnmarshalJSON(data []byte) error {
	type unmarshaler TemplatesConfig
	var value unmarshaler
	if err := json.Unmarshal(data, &value); err != nil {
		return err
	}
	*t = TemplatesConfig(value)
	extraProperties, err := internal.ExtractExtraProperties(data, *t)
	if err != nil {
		return err
	}
	t.extraProperties = extraProperties
	t.rawJSON = json.RawMessage(data)
	return nil
}

func (t *TemplatesConfig) String() string {
	if len(t.rawJSON) > 0 {
		if value, err := internal.StringifyJSON(t.rawJSON); err == nil {
			return value
		}
	}
	if value, err := internal.StringifyJSON(t); err == nil {
		return value
	}
	return fmt.Sprintf("%#v", t)
}

type TemplatesIacInputData struct {
	Data       map[string]interface{} `json:"data,omitempty" url:"data,omitempty"`
	SchemaType string                 `json:"schemaType" url:"schemaType"`

	extraProperties map[string]interface{}
	rawJSON         json.RawMessage
}

func (t *TemplatesIacInputData) GetData() map[string]interface{} {
	if t == nil {
		return nil
	}
	return t.Data
}

func (t *TemplatesIacInputData) GetSchemaType() string {
	if t == nil {
		return ""
	}
	return t.SchemaType
}

func (t *TemplatesIacInputData) GetExtraProperties() map[string]interface{} {
	return t.extraProperties
}

func (t *TemplatesIacInputData) UnmarshalJSON(data []byte) error {
	type unmarshaler TemplatesIacInputData
	var value unmarshaler
	if err := json.Unmarshal(data, &value); err != nil {
		return err
	}
	*t = TemplatesIacInputData(value)
	extraProperties, err := internal.ExtractExtraProperties(data, *t)
	if err != nil {
		return err
	}
	t.extraProperties = extraProperties
	t.rawJSON = json.RawMessage(data)
	return nil
}

func (t *TemplatesIacInputData) String() string {
	if len(t.rawJSON) > 0 {
		if value, err := internal.StringifyJSON(t.rawJSON); err == nil {
			return value
		}
	}
	if value, err := internal.StringifyJSON(t); err == nil {
		return value
	}
	return fmt.Sprintf("%#v", t)
}

type TerraformAction struct {
	Action *ActionEnum `json:"action,omitempty" url:"action,omitempty"`

	extraProperties map[string]interface{}
	rawJSON         json.RawMessage
}

func (t *TerraformAction) GetAction() *ActionEnum {
	if t == nil {
		return nil
	}
	return t.Action
}

func (t *TerraformAction) GetExtraProperties() map[string]interface{} {
	return t.extraProperties
}

func (t *TerraformAction) UnmarshalJSON(data []byte) error {
	type unmarshaler TerraformAction
	var value unmarshaler
	if err := json.Unmarshal(data, &value); err != nil {
		return err
	}
	*t = TerraformAction(value)
	extraProperties, err := internal.ExtractExtraProperties(data, *t)
	if err != nil {
		return err
	}
	t.extraProperties = extraProperties
	t.rawJSON = json.RawMessage(data)
	return nil
}

func (t *TerraformAction) String() string {
	if len(t.rawJSON) > 0 {
		if value, err := internal.StringifyJSON(t.rawJSON); err == nil {
			return value
		}
	}
	if value, err := internal.StringifyJSON(t); err == nil {
		return value
	}
	return fmt.Sprintf("%#v", t)
}

type TerraformConfig struct {
	TerraformVersion        *string          `json:"terraformVersion,omitempty" url:"terraformVersion,omitempty"`
	DriftCheck              *bool            `json:"driftCheck,omitempty" url:"driftCheck,omitempty"`
	DriftCron               *string          `json:"driftCron,omitempty" url:"driftCron,omitempty"`
	ManagedTerraformState   *bool            `json:"managedTerraformState,omitempty" url:"managedTerraformState,omitempty"`
	ApprovalPreApply        *bool            `json:"approvalPreApply,omitempty" url:"approvalPreApply,omitempty"`
	TerraformPlanOptions    *string          `json:"terraformPlanOptions,omitempty" url:"terraformPlanOptions,omitempty"`
	TerraformInitOptions    *string          `json:"terraformInitOptions,omitempty" url:"terraformInitOptions,omitempty"`
	TerraformBinPath        []*MountPoint    `json:"terraformBinPath,omitempty" url:"terraformBinPath,omitempty"`
	Timeout                 *int             `json:"timeout,omitempty" url:"timeout,omitempty"`
	PostApplyWfStepsConfig  []*WfStepsConfig `json:"postApplyWfStepsConfig,omitempty" url:"postApplyWfStepsConfig,omitempty"`
	PreApplyWfStepsConfig   []*WfStepsConfig `json:"preApplyWfStepsConfig,omitempty" url:"preApplyWfStepsConfig,omitempty"`
	PrePlanWfStepsConfig    []*WfStepsConfig `json:"prePlanWfStepsConfig,omitempty" url:"prePlanWfStepsConfig,omitempty"`
	PostPlanWfStepsConfig   []*WfStepsConfig `json:"postPlanWfStepsConfig,omitempty" url:"postPlanWfStepsConfig,omitempty"`
	PreInitHooks            []string         `json:"preInitHooks,omitempty" url:"preInitHooks,omitempty"`
	PrePlanHooks            []string         `json:"prePlanHooks,omitempty" url:"prePlanHooks,omitempty"`
	PostPlanHooks           []string         `json:"postPlanHooks,omitempty" url:"postPlanHooks,omitempty"`
	PreApplyHooks           []string         `json:"preApplyHooks,omitempty" url:"preApplyHooks,omitempty"`
	PostApplyHooks          []string         `json:"postApplyHooks,omitempty" url:"postApplyHooks,omitempty"`
	RunPreInitHooksOnDrift  *bool            `json:"runPreInitHooksOnDrift,omitempty" url:"runPreInitHooksOnDrift,omitempty"`
	RunPrePlanHooksOnDrift  *bool            `json:"runPrePlanHooksOnDrift,omitempty" url:"runPrePlanHooksOnDrift,omitempty"`
	RunPostPlanHooksOnDrift *bool            `json:"runPostPlanHooksOnDrift,omitempty" url:"runPostPlanHooksOnDrift,omitempty"`

	extraProperties map[string]interface{}
	rawJSON         json.RawMessage
}

func (t *TerraformConfig) GetTerraformVersion() *string {
	if t == nil {
		return nil
	}
	return t.TerraformVersion
}

func (t *TerraformConfig) GetDriftCheck() *bool {
	if t == nil {
		return nil
	}
	return t.DriftCheck
}

func (t *TerraformConfig) GetDriftCron() *string {
	if t == nil {
		return nil
	}
	return t.DriftCron
}

func (t *TerraformConfig) GetManagedTerraformState() *bool {
	if t == nil {
		return nil
	}
	return t.ManagedTerraformState
}

func (t *TerraformConfig) GetApprovalPreApply() *bool {
	if t == nil {
		return nil
	}
	return t.ApprovalPreApply
}

func (t *TerraformConfig) GetTerraformPlanOptions() *string {
	if t == nil {
		return nil
	}
	return t.TerraformPlanOptions
}

func (t *TerraformConfig) GetTerraformInitOptions() *string {
	if t == nil {
		return nil
	}
	return t.TerraformInitOptions
}

func (t *TerraformConfig) GetTerraformBinPath() []*MountPoint {
	if t == nil {
		return nil
	}
	return t.TerraformBinPath
}

func (t *TerraformConfig) GetTimeout() *int {
	if t == nil {
		return nil
	}
	return t.Timeout
}

func (t *TerraformConfig) GetPostApplyWfStepsConfig() []*WfStepsConfig {
	if t == nil {
		return nil
	}
	return t.PostApplyWfStepsConfig
}

func (t *TerraformConfig) GetPreApplyWfStepsConfig() []*WfStepsConfig {
	if t == nil {
		return nil
	}
	return t.PreApplyWfStepsConfig
}

func (t *TerraformConfig) GetPrePlanWfStepsConfig() []*WfStepsConfig {
	if t == nil {
		return nil
	}
	return t.PrePlanWfStepsConfig
}

func (t *TerraformConfig) GetPostPlanWfStepsConfig() []*WfStepsConfig {
	if t == nil {
		return nil
	}
	return t.PostPlanWfStepsConfig
}

func (t *TerraformConfig) GetPreInitHooks() []string {
	if t == nil {
		return nil
	}
	return t.PreInitHooks
}

func (t *TerraformConfig) GetPrePlanHooks() []string {
	if t == nil {
		return nil
	}
	return t.PrePlanHooks
}

func (t *TerraformConfig) GetPostPlanHooks() []string {
	if t == nil {
		return nil
	}
	return t.PostPlanHooks
}

func (t *TerraformConfig) GetPreApplyHooks() []string {
	if t == nil {
		return nil
	}
	return t.PreApplyHooks
}

func (t *TerraformConfig) GetPostApplyHooks() []string {
	if t == nil {
		return nil
	}
	return t.PostApplyHooks
}

func (t *TerraformConfig) GetRunPreInitHooksOnDrift() *bool {
	if t == nil {
		return nil
	}
	return t.RunPreInitHooksOnDrift
}

func (t *TerraformConfig) GetRunPrePlanHooksOnDrift() *bool {
	if t == nil {
		return nil
	}
	return t.RunPrePlanHooksOnDrift
}

func (t *TerraformConfig) GetRunPostPlanHooksOnDrift() *bool {
	if t == nil {
		return nil
	}
	return t.RunPostPlanHooksOnDrift
}

func (t *TerraformConfig) GetExtraProperties() map[string]interface{} {
	return t.extraProperties
}

func (t *TerraformConfig) UnmarshalJSON(data []byte) error {
	type unmarshaler TerraformConfig
	var value unmarshaler
	if err := json.Unmarshal(data, &value); err != nil {
		return err
	}
	*t = TerraformConfig(value)
	extraProperties, err := internal.ExtractExtraProperties(data, *t)
	if err != nil {
		return err
	}
	t.extraProperties = extraProperties
	t.rawJSON = json.RawMessage(data)
	return nil
}

func (t *TerraformConfig) String() string {
	if len(t.rawJSON) > 0 {
		if value, err := internal.StringifyJSON(t.rawJSON); err == nil {
			return value
		}
	}
	if value, err := internal.StringifyJSON(t); err == nil {
		return value
	}
	return fmt.Sprintf("%#v", t)
}

type UserSchedules struct {
	Name   *string      `json:"name,omitempty" url:"name,omitempty"`
	Desc   *string      `json:"desc,omitempty" url:"desc,omitempty"`
	Cron   string       `json:"cron" url:"cron"`
	State  StateEnum    `json:"state" url:"state"`
	Inputs *WorkflowRun `json:"inputs,omitempty" url:"inputs,omitempty"`

	extraProperties map[string]interface{}
	rawJSON         json.RawMessage
}

func (u *UserSchedules) GetName() *string {
	if u == nil {
		return nil
	}
	return u.Name
}

func (u *UserSchedules) GetDesc() *string {
	if u == nil {
		return nil
	}
	return u.Desc
}

func (u *UserSchedules) GetCron() string {
	if u == nil {
		return ""
	}
	return u.Cron
}

func (u *UserSchedules) GetState() StateEnum {
	if u == nil {
		return ""
	}
	return u.State
}

func (u *UserSchedules) GetInputs() *WorkflowRun {
	if u == nil {
		return nil
	}
	return u.Inputs
}

func (u *UserSchedules) GetExtraProperties() map[string]interface{} {
	return u.extraProperties
}

func (u *UserSchedules) UnmarshalJSON(data []byte) error {
	type unmarshaler UserSchedules
	var value unmarshaler
	if err := json.Unmarshal(data, &value); err != nil {
		return err
	}
	*u = UserSchedules(value)
	extraProperties, err := internal.ExtractExtraProperties(data, *u)
	if err != nil {
		return err
	}
	u.extraProperties = extraProperties
	u.rawJSON = json.RawMessage(data)
	return nil
}

func (u *UserSchedules) String() string {
	if len(u.rawJSON) > 0 {
		if value, err := internal.StringifyJSON(u.rawJSON); err == nil {
			return value
		}
	}
	if value, err := internal.StringifyJSON(u); err == nil {
		return value
	}
	return fmt.Sprintf("%#v", u)
}

type VcsConfig struct {
	IacVcsConfig *IacvcsConfig `json:"iacVCSConfig,omitempty" url:"iacVCSConfig,omitempty"`
	IacInputData *IacInputData `json:"iacInputData,omitempty" url:"iacInputData,omitempty"`

	extraProperties map[string]interface{}
	rawJSON         json.RawMessage
}

func (v *VcsConfig) GetIacVcsConfig() *IacvcsConfig {
	if v == nil {
		return nil
	}
	return v.IacVcsConfig
}

func (v *VcsConfig) GetIacInputData() *IacInputData {
	if v == nil {
		return nil
	}
	return v.IacInputData
}

func (v *VcsConfig) GetExtraProperties() map[string]interface{} {
	return v.extraProperties
}

func (v *VcsConfig) UnmarshalJSON(data []byte) error {
	type unmarshaler VcsConfig
	var value unmarshaler
	if err := json.Unmarshal(data, &value); err != nil {
		return err
	}
	*v = VcsConfig(value)
	extraProperties, err := internal.ExtractExtraProperties(data, *v)
	if err != nil {
		return err
	}
	v.extraProperties = extraProperties
	v.rawJSON = json.RawMessage(data)
	return nil
}

func (v *VcsConfig) String() string {
	if len(v.rawJSON) > 0 {
		if value, err := internal.StringifyJSON(v.rawJSON); err == nil {
			return value
		}
	}
	if value, err := internal.StringifyJSON(v); err == nil {
		return value
	}
	return fmt.Sprintf("%#v", v)
}

type WebhookTypes struct {
	ApprovalRequired []map[string]interface{} `json:"APPROVAL_REQUIRED,omitempty" url:"APPROVAL_REQUIRED,omitempty"`
	Cancelled        []map[string]interface{} `json:"CANCELLED,omitempty" url:"CANCELLED,omitempty"`
	Completed        []map[string]interface{} `json:"COMPLETED,omitempty" url:"COMPLETED,omitempty"`
	Errored          []map[string]interface{} `json:"ERRORED,omitempty" url:"ERRORED,omitempty"`
	DriftDetected    []map[string]interface{} `json:"DRIFT_DETECTED,omitempty" url:"DRIFT_DETECTED,omitempty"`

	extraProperties map[string]interface{}
	rawJSON         json.RawMessage
}

func (w *WebhookTypes) GetApprovalRequired() []map[string]interface{} {
	if w == nil {
		return nil
	}
	return w.ApprovalRequired
}

func (w *WebhookTypes) GetCancelled() []map[string]interface{} {
	if w == nil {
		return nil
	}
	return w.Cancelled
}

func (w *WebhookTypes) GetCompleted() []map[string]interface{} {
	if w == nil {
		return nil
	}
	return w.Completed
}

func (w *WebhookTypes) GetErrored() []map[string]interface{} {
	if w == nil {
		return nil
	}
	return w.Errored
}

func (w *WebhookTypes) GetDriftDetected() []map[string]interface{} {
	if w == nil {
		return nil
	}
	return w.DriftDetected
}

func (w *WebhookTypes) GetExtraProperties() map[string]interface{} {
	return w.extraProperties
}

func (w *WebhookTypes) UnmarshalJSON(data []byte) error {
	type unmarshaler WebhookTypes
	var value unmarshaler
	if err := json.Unmarshal(data, &value); err != nil {
		return err
	}
	*w = WebhookTypes(value)
	extraProperties, err := internal.ExtractExtraProperties(data, *w)
	if err != nil {
		return err
	}
	w.extraProperties = extraProperties
	w.rawJSON = json.RawMessage(data)
	return nil
}

func (w *WebhookTypes) String() string {
	if len(w.rawJSON) > 0 {
		if value, err := internal.StringifyJSON(w.rawJSON); err == nil {
			return value
		}
	}
	if value, err := internal.StringifyJSON(w); err == nil {
		return value
	}
	return fmt.Sprintf("%#v", w)
}

type WfChainingPayloadPayload struct {
	Completed []*MiniSteps `json:"COMPLETED,omitempty" url:"COMPLETED,omitempty"`
	Errored   []*MiniSteps `json:"ERRORED,omitempty" url:"ERRORED,omitempty"`

	extraProperties map[string]interface{}
	rawJSON         json.RawMessage
}

func (w *WfChainingPayloadPayload) GetCompleted() []*MiniSteps {
	if w == nil {
		return nil
	}
	return w.Completed
}

func (w *WfChainingPayloadPayload) GetErrored() []*MiniSteps {
	if w == nil {
		return nil
	}
	return w.Errored
}

func (w *WfChainingPayloadPayload) GetExtraProperties() map[string]interface{} {
	return w.extraProperties
}

func (w *WfChainingPayloadPayload) UnmarshalJSON(data []byte) error {
	type unmarshaler WfChainingPayloadPayload
	var value unmarshaler
	if err := json.Unmarshal(data, &value); err != nil {
		return err
	}
	*w = WfChainingPayloadPayload(value)
	extraProperties, err := internal.ExtractExtraProperties(data, *w)
	if err != nil {
		return err
	}
	w.extraProperties = extraProperties
	w.rawJSON = json.RawMessage(data)
	return nil
}

func (w *WfChainingPayloadPayload) String() string {
	if len(w.rawJSON) > 0 {
		if value, err := internal.StringifyJSON(w.rawJSON); err == nil {
			return value
		}
	}
	if value, err := internal.StringifyJSON(w); err == nil {
		return value
	}
	return fmt.Sprintf("%#v", w)
}

type WfStepInputData struct {
	SchemaType WfStepInputDataSchemaTypeEnum `json:"schemaType,omitempty" url:"schemaType,omitempty"`
	Data       map[string]interface{}        `json:"data,omitempty" url:"data,omitempty"`

	extraProperties map[string]interface{}
	rawJSON         json.RawMessage
}

func (w *WfStepInputData) GetData() map[string]interface{} {
	if w == nil {
		return nil
	}
	return w.Data
}

func (w *WfStepInputData) GetExtraProperties() map[string]interface{} {
	return w.extraProperties
}

func (w *WfStepInputData) UnmarshalJSON(data []byte) error {
	type unmarshaler WfStepInputData
	var value unmarshaler
	if err := json.Unmarshal(data, &value); err != nil {
		return err
	}
	*w = WfStepInputData(value)
	extraProperties, err := internal.ExtractExtraProperties(data, *w)
	if err != nil {
		return err
	}
	w.extraProperties = extraProperties
	w.rawJSON = json.RawMessage(data)
	return nil
}

func (w *WfStepInputData) String() string {
	if len(w.rawJSON) > 0 {
		if value, err := internal.StringifyJSON(w.rawJSON); err == nil {
			return value
		}
	}
	if value, err := internal.StringifyJSON(w); err == nil {
		return value
	}
	return fmt.Sprintf("%#v", w)
}

// * `FORM_JSONSCHEMA` - FORM_JSONSCHEMA
type WfStepInputDataSchemaTypeEnum = string

type WfStepsConfig struct {
	Name                 string           `json:"name" url:"name"`
	EnvironmentVariables []*EnvVars       `json:"environmentVariables,omitempty" url:"environmentVariables,omitempty"`
	Approval             *bool            `json:"approval,omitempty" url:"approval,omitempty"`
	Timeout              *int             `json:"timeout,omitempty" url:"timeout,omitempty"`
	CmdOverride          interface{}      `json:"cmdOverride,omitempty" url:"cmdOverride,omitempty"`
	MountPoints          []*MountPoint    `json:"mountPoints,omitempty" url:"mountPoints,omitempty"`
	WfStepTemplateId     *string          `json:"wfStepTemplateId,omitempty" url:"wfStepTemplateId,omitempty"`
	WfStepInputData      *WfStepInputData `json:"wfStepInputData,omitempty" url:"wfStepInputData,omitempty"`

	extraProperties map[string]interface{}
	rawJSON         json.RawMessage
}

func (w *WfStepsConfig) GetName() string {
	if w == nil {
		return ""
	}
	return w.Name
}

func (w *WfStepsConfig) GetEnvironmentVariables() []*EnvVars {
	if w == nil {
		return nil
	}
	return w.EnvironmentVariables
}

func (w *WfStepsConfig) GetApproval() *bool {
	if w == nil {
		return nil
	}
	return w.Approval
}

func (w *WfStepsConfig) GetTimeout() *int {
	if w == nil {
		return nil
	}
	return w.Timeout
}

func (w *WfStepsConfig) GetCmdOverride() interface{} {
	if w == nil {
		return nil
	}
	return w.CmdOverride
}

func (w *WfStepsConfig) GetMountPoints() []*MountPoint {
	if w == nil {
		return nil
	}
	return w.MountPoints
}

func (w *WfStepsConfig) GetWfStepTemplateId() *string {
	if w == nil {
		return nil
	}
	return w.WfStepTemplateId
}

func (w *WfStepsConfig) GetWfStepInputData() *WfStepInputData {
	if w == nil {
		return nil
	}
	return w.WfStepInputData
}

func (w *WfStepsConfig) GetExtraProperties() map[string]interface{} {
	return w.extraProperties
}

func (w *WfStepsConfig) UnmarshalJSON(data []byte) error {
	type unmarshaler WfStepsConfig
	var value unmarshaler
	if err := json.Unmarshal(data, &value); err != nil {
		return err
	}
	*w = WfStepsConfig(value)
	extraProperties, err := internal.ExtractExtraProperties(data, *w)
	if err != nil {
		return err
	}
	w.extraProperties = extraProperties
	w.rawJSON = json.RawMessage(data)
	return nil
}

func (w *WfStepsConfig) String() string {
	if len(w.rawJSON) > 0 {
		if value, err := internal.StringifyJSON(w.rawJSON); err == nil {
			return value
		}
	}
	if value, err := internal.StringifyJSON(w); err == nil {
		return value
	}
	return fmt.Sprintf("%#v", w)
}

// * `TERRAFORM` - TERRAFORM
// * `OPENTOFU` - OPENTOFU
// * `CUSTOM` - CUSTOM
type WfTypeEnum string

const (
	WfTypeEnumTerraform WfTypeEnum = "TERRAFORM"
	WfTypeEnumOpentofu  WfTypeEnum = "OPENTOFU"
	WfTypeEnumCustom    WfTypeEnum = "CUSTOM"
)

func NewWfTypeEnumFromString(s string) (WfTypeEnum, error) {
	switch s {
	case "TERRAFORM":
		return WfTypeEnumTerraform, nil
	case "OPENTOFU":
		return WfTypeEnumOpentofu, nil
	case "CUSTOM":
		return WfTypeEnumCustom, nil
	}
	var t WfTypeEnum
	return "", fmt.Errorf("%s is not a valid %T", s, t)
}

func (w WfTypeEnum) Ptr() *WfTypeEnum {
	return &w
}

type WorkflowGetResponse struct {
	Msg *GeneratedWorkflowGetMsg `json:"msg,omitempty" url:"msg,omitempty"`

	extraProperties map[string]interface{}
	rawJSON         json.RawMessage
}

func (w *WorkflowGetResponse) GetMsg() *GeneratedWorkflowGetMsg {
	if w == nil {
		return nil
	}
	return w.Msg
}

func (w *WorkflowGetResponse) GetExtraProperties() map[string]interface{} {
	return w.extraProperties
}

func (w *WorkflowGetResponse) UnmarshalJSON(data []byte) error {
	type unmarshaler WorkflowGetResponse
	var value unmarshaler
	if err := json.Unmarshal(data, &value); err != nil {
		return err
	}
	*w = WorkflowGetResponse(value)
	extraProperties, err := internal.ExtractExtraProperties(data, *w)
	if err != nil {
		return err
	}
	w.extraProperties = extraProperties
	w.rawJSON = json.RawMessage(data)
	return nil
}

func (w *WorkflowGetResponse) String() string {
	if len(w.rawJSON) > 0 {
		if value, err := internal.StringifyJSON(w.rawJSON); err == nil {
			return value
		}
	}
	if value, err := internal.StringifyJSON(w); err == nil {
		return value
	}
	return fmt.Sprintf("%#v", w)
}

type WorkflowRun struct {
	DeploymentPlatformConfig []*DeploymentPlatformConfig `json:"DeploymentPlatformConfig,omitempty" url:"DeploymentPlatformConfig,omitempty"`
	WfStepsConfig            []*WfStepsConfig            `json:"WfStepsConfig,omitempty" url:"WfStepsConfig,omitempty"`
	EnvironmentVariables     []*EnvVars                  `json:"EnvironmentVariables,omitempty" url:"EnvironmentVariables,omitempty"`
	WfType                   *WfTypeEnum                 `json:"WfType,omitempty" url:"WfType,omitempty"`
	TerraformConfig          map[string]interface{}      `json:"TerraformConfig,omitempty" url:"TerraformConfig,omitempty"`
	TerraformAction          *TerraformAction            `json:"TerraformAction,omitempty" url:"TerraformAction,omitempty"`
	TriggerDetails           map[string]interface{}      `json:"TriggerDetails,omitempty" url:"TriggerDetails,omitempty"`
	ScheduledAt              *string                     `json:"ScheduledAt,omitempty" url:"ScheduledAt,omitempty"`
	VcsConfig                *VcsConfig                  `json:"VCSConfig,omitempty" url:"VCSConfig,omitempty"`
	SgInternals              map[string]interface{}      `json:"SGInternals,omitempty" url:"SGInternals,omitempty"`
	RunnerConstraints        *RunnerConstraints          `json:"RunnerConstraints,omitempty" url:"RunnerConstraints,omitempty"`
	UserJobCpu               *int                        `json:"UserJobCPU,omitempty" url:"UserJobCPU,omitempty"`
	UserJobMemory            *int                        `json:"UserJobMemory,omitempty" url:"UserJobMemory,omitempty"`
	EnableChaining           *bool                       `json:"EnableChaining,omitempty" url:"EnableChaining,omitempty"`
	MiniSteps                map[string]interface{}      `json:"MiniSteps,omitempty" url:"MiniSteps,omitempty"`

	extraProperties map[string]interface{}
	rawJSON         json.RawMessage
}

func (w *WorkflowRun) GetDeploymentPlatformConfig() []*DeploymentPlatformConfig {
	if w == nil {
		return nil
	}
	return w.DeploymentPlatformConfig
}

func (w *WorkflowRun) GetWfStepsConfig() []*WfStepsConfig {
	if w == nil {
		return nil
	}
	return w.WfStepsConfig
}

func (w *WorkflowRun) GetEnvironmentVariables() []*EnvVars {
	if w == nil {
		return nil
	}
	return w.EnvironmentVariables
}

func (w *WorkflowRun) GetWfType() *WfTypeEnum {
	if w == nil {
		return nil
	}
	return w.WfType
}

func (w *WorkflowRun) GetTerraformConfig() map[string]interface{} {
	if w == nil {
		return nil
	}
	return w.TerraformConfig
}

func (w *WorkflowRun) GetTerraformAction() *TerraformAction {
	if w == nil {
		return nil
	}
	return w.TerraformAction
}

func (w *WorkflowRun) GetTriggerDetails() map[string]interface{} {
	if w == nil {
		return nil
	}
	return w.TriggerDetails
}

func (w *WorkflowRun) GetScheduledAt() *string {
	if w == nil {
		return nil
	}
	return w.ScheduledAt
}

func (w *WorkflowRun) GetVcsConfig() *VcsConfig {
	if w == nil {
		return nil
	}
	return w.VcsConfig
}

func (w *WorkflowRun) GetSgInternals() map[string]interface{} {
	if w == nil {
		return nil
	}
	return w.SgInternals
}

func (w *WorkflowRun) GetRunnerConstraints() *RunnerConstraints {
	if w == nil {
		return nil
	}
	return w.RunnerConstraints
}

func (w *WorkflowRun) GetUserJobCpu() *int {
	if w == nil {
		return nil
	}
	return w.UserJobCpu
}

func (w *WorkflowRun) GetUserJobMemory() *int {
	if w == nil {
		return nil
	}
	return w.UserJobMemory
}

func (w *WorkflowRun) GetEnableChaining() *bool {
	if w == nil {
		return nil
	}
	return w.EnableChaining
}

func (w *WorkflowRun) GetMiniSteps() map[string]interface{} {
	if w == nil {
		return nil
	}
	return w.MiniSteps
}

func (w *WorkflowRun) GetExtraProperties() map[string]interface{} {
	return w.extraProperties
}

func (w *WorkflowRun) UnmarshalJSON(data []byte) error {
	type unmarshaler WorkflowRun
	var value unmarshaler
	if err := json.Unmarshal(data, &value); err != nil {
		return err
	}
	*w = WorkflowRun(value)
	extraProperties, err := internal.ExtractExtraProperties(data, *w)
	if err != nil {
		return err
	}
	w.extraProperties = extraProperties
	w.rawJSON = json.RawMessage(data)
	return nil
}

func (w *WorkflowRun) String() string {
	if len(w.rawJSON) > 0 {
		if value, err := internal.StringifyJSON(w.rawJSON); err == nil {
			return value
		}
	}
	if value, err := internal.StringifyJSON(w); err == nil {
		return value
	}
	return fmt.Sprintf("%#v", w)
}

type WorkflowRunApproval struct {
	Message                   *string `json:"Message,omitempty" url:"Message,omitempty"`
	ApprovalStep              *string `json:"ApprovalStep,omitempty" url:"ApprovalStep,omitempty"`
	Approve                   *bool   `json:"Approve,omitempty" url:"Approve,omitempty"`
	ReasonForApprovalRequired *string `json:"ReasonForApprovalRequired,omitempty" url:"ReasonForApprovalRequired,omitempty"`

	extraProperties map[string]interface{}
	rawJSON         json.RawMessage
}

func (w *WorkflowRunApproval) GetMessage() *string {
	if w == nil {
		return nil
	}
	return w.Message
}

func (w *WorkflowRunApproval) GetApprovalStep() *string {
	if w == nil {
		return nil
	}
	return w.ApprovalStep
}

func (w *WorkflowRunApproval) GetApprove() *bool {
	if w == nil {
		return nil
	}
	return w.Approve
}

func (w *WorkflowRunApproval) GetReasonForApprovalRequired() *string {
	if w == nil {
		return nil
	}
	return w.ReasonForApprovalRequired
}

func (w *WorkflowRunApproval) GetExtraProperties() map[string]interface{} {
	return w.extraProperties
}

func (w *WorkflowRunApproval) UnmarshalJSON(data []byte) error {
	type unmarshaler WorkflowRunApproval
	var value unmarshaler
	if err := json.Unmarshal(data, &value); err != nil {
		return err
	}
	*w = WorkflowRunApproval(value)
	extraProperties, err := internal.ExtractExtraProperties(data, *w)
	if err != nil {
		return err
	}
	w.extraProperties = extraProperties
	w.rawJSON = json.RawMessage(data)
	return nil
}

func (w *WorkflowRunApproval) String() string {
	if len(w.rawJSON) > 0 {
		if value, err := internal.StringifyJSON(w.rawJSON); err == nil {
			return value
		}
	}
	if value, err := internal.StringifyJSON(w); err == nil {
		return value
	}
	return fmt.Sprintf("%#v", w)
}

type WorkflowsConfig struct {
	Workflows []*WorkflowsConfigWorkflow `json:"workflows,omitempty" url:"workflows,omitempty"`

	extraProperties map[string]interface{}
	rawJSON         json.RawMessage
}

func (w *WorkflowsConfig) GetWorkflows() []*WorkflowsConfigWorkflow {
	if w == nil {
		return nil
	}
	return w.Workflows
}

func (w *WorkflowsConfig) GetExtraProperties() map[string]interface{} {
	return w.extraProperties
}

func (w *WorkflowsConfig) UnmarshalJSON(data []byte) error {
	type unmarshaler WorkflowsConfig
	var value unmarshaler
	if err := json.Unmarshal(data, &value); err != nil {
		return err
	}
	*w = WorkflowsConfig(value)
	extraProperties, err := internal.ExtractExtraProperties(data, *w)
	if err != nil {
		return err
	}
	w.extraProperties = extraProperties
	w.rawJSON = json.RawMessage(data)
	return nil
}

func (w *WorkflowsConfig) String() string {
	if len(w.rawJSON) > 0 {
		if value, err := internal.StringifyJSON(w.rawJSON); err == nil {
			return value
		}
	}
	if value, err := internal.StringifyJSON(w); err == nil {
		return value
	}
	return fmt.Sprintf("%#v", w)
}

type WorkflowsConfigWorkflow struct {
	ResourceName                *string                     `json:"ResourceName,omitempty" url:"ResourceName,omitempty"`
	Description                 *string                     `json:"Description,omitempty" url:"Description,omitempty"`
	Tags                        []string                    `json:"Tags,omitempty" url:"Tags,omitempty"`
	IsActive                    *IsArchiveEnum              `json:"IsActive,omitempty" url:"IsActive,omitempty"`
	WfStepsConfig               []*WfStepsConfig            `json:"WfStepsConfig,omitempty" url:"WfStepsConfig,omitempty"`
	WfType                      *WfTypeEnum                 `json:"WfType,omitempty" url:"WfType,omitempty"`
	TerraformConfig             *TerraformConfig            `json:"TerraformConfig,omitempty" url:"TerraformConfig,omitempty"`
	EnvironmentVariables        []*EnvVars                  `json:"EnvironmentVariables,omitempty" url:"EnvironmentVariables,omitempty"`
	DeploymentPlatformConfig    []*DeploymentPlatformConfig `json:"DeploymentPlatformConfig,omitempty" url:"DeploymentPlatformConfig,omitempty"`
	VcsConfig                   *VcsConfig                  `json:"VCSConfig,omitempty" url:"VCSConfig,omitempty"`
	UserSchedules               []*UserSchedules            `json:"UserSchedules,omitempty" url:"UserSchedules,omitempty"`
	GitHubComSync               map[string]interface{}      `json:"GitHubComSync,omitempty" url:"GitHubComSync,omitempty"`
	MiniSteps                   *MiniStepsSchema            `json:"MiniSteps,omitempty" url:"MiniSteps,omitempty"`
	Approvers                   []string                    `json:"Approvers,omitempty" url:"Approvers,omitempty"`
	NumberOfApprovalsRequired   *int                        `json:"NumberOfApprovalsRequired,omitempty" url:"NumberOfApprovalsRequired,omitempty"`
	RunnerConstraints           *RunnerConstraints          `json:"RunnerConstraints,omitempty" url:"RunnerConstraints,omitempty"`
	UserJobCpu                  *int                        `json:"UserJobCPU,omitempty" url:"UserJobCPU,omitempty"`
	UserJobMemory               *int                        `json:"UserJobMemory,omitempty" url:"UserJobMemory,omitempty"`
	CacheConfig                 *CacheConfig                `json:"CacheConfig,omitempty" url:"CacheConfig,omitempty"`
	TfStateCleaned              map[string]interface{}      `json:"TfStateCleaned,omitempty" url:"TfStateCleaned,omitempty"`
	InfracostBreakdown          map[string]interface{}      `json:"InfracostBreakdown,omitempty" url:"InfracostBreakdown,omitempty"`
	PolicyEvalResults           map[string]interface{}      `json:"PolicyEvalResults,omitempty" url:"PolicyEvalResults,omitempty"`
	InfracostBreakdownPreApply  map[string]interface{}      `json:"InfracostBreakdownPreApply,omitempty" url:"InfracostBreakdownPreApply,omitempty"`
	InfracostBreakdownPostApply map[string]interface{}      `json:"InfracostBreakdownPostApply,omitempty" url:"InfracostBreakdownPostApply,omitempty"`
	TfDrift                     map[string]interface{}      `json:"TfDrift,omitempty" url:"TfDrift,omitempty"`
	CfStateCleaned              map[string]interface{}      `json:"CfStateCleaned,omitempty" url:"CfStateCleaned,omitempty"`
	CfStackPlan                 map[string]interface{}      `json:"CfStackPlan,omitempty" url:"CfStackPlan,omitempty"`
	CfDrift                     map[string]interface{}      `json:"CfDrift,omitempty" url:"CfDrift,omitempty"`
	K8SResources                map[string]interface{}      `json:"K8sResources,omitempty" url:"K8sResources,omitempty"`
	K8SDrift                    map[string]interface{}      `json:"K8sDrift,omitempty" url:"K8sDrift,omitempty"`
	TerragruntDrift             map[string]interface{}      `json:"TerragruntDrift,omitempty" url:"TerragruntDrift,omitempty"`
	AnsibleOutputs              map[string]interface{}      `json:"AnsibleOutputs,omitempty" url:"AnsibleOutputs,omitempty"`
	AnsiblePlan                 map[string]interface{}      `json:"AnsiblePlan,omitempty" url:"AnsiblePlan,omitempty"`
	AnsibleDrift                map[string]interface{}      `json:"AnsibleDrift,omitempty" url:"AnsibleDrift,omitempty"`
	BicepResources              map[string]interface{}      `json:"BicepResources,omitempty" url:"BicepResources,omitempty"`
	SgCustomWorkflowRunFacts    map[string]interface{}      `json:"SGCustomWorkflowRunFacts,omitempty" url:"SGCustomWorkflowRunFacts,omitempty"`
	// Contextual tags to give context to your tags
	ContextTags  map[string]*string     `json:"ContextTags,omitempty" url:"ContextTags,omitempty"`
	Id           *string                `json:"id,omitempty" url:"id,omitempty"`
	TemplateId   *string                `json:"templateId,omitempty" url:"templateId,omitempty"`
	IacInputData *TemplatesIacInputData `json:"iacInputData,omitempty" url:"iacInputData,omitempty"`
	InputSchemas []*InputSchemas        `json:"inputSchemas,omitempty" url:"inputSchemas,omitempty"`

	extraProperties map[string]interface{}
	rawJSON         json.RawMessage
}

func (w *WorkflowsConfigWorkflow) GetResourceName() *string {
	if w == nil {
		return nil
	}
	return w.ResourceName
}

func (w *WorkflowsConfigWorkflow) GetDescription() *string {
	if w == nil {
		return nil
	}
	return w.Description
}

func (w *WorkflowsConfigWorkflow) GetTags() []string {
	if w == nil {
		return nil
	}
	return w.Tags
}

func (w *WorkflowsConfigWorkflow) GetIsActive() *IsArchiveEnum {
	if w == nil {
		return nil
	}
	return w.IsActive
}

func (w *WorkflowsConfigWorkflow) GetWfStepsConfig() []*WfStepsConfig {
	if w == nil {
		return nil
	}
	return w.WfStepsConfig
}

func (w *WorkflowsConfigWorkflow) GetWfType() *WfTypeEnum {
	if w == nil {
		return nil
	}
	return w.WfType
}

func (w *WorkflowsConfigWorkflow) GetTerraformConfig() *TerraformConfig {
	if w == nil {
		return nil
	}
	return w.TerraformConfig
}

func (w *WorkflowsConfigWorkflow) GetEnvironmentVariables() []*EnvVars {
	if w == nil {
		return nil
	}
	return w.EnvironmentVariables
}

func (w *WorkflowsConfigWorkflow) GetDeploymentPlatformConfig() []*DeploymentPlatformConfig {
	if w == nil {
		return nil
	}
	return w.DeploymentPlatformConfig
}

func (w *WorkflowsConfigWorkflow) GetVcsConfig() *VcsConfig {
	if w == nil {
		return nil
	}
	return w.VcsConfig
}

func (w *WorkflowsConfigWorkflow) GetUserSchedules() []*UserSchedules {
	if w == nil {
		return nil
	}
	return w.UserSchedules
}

func (w *WorkflowsConfigWorkflow) GetGitHubComSync() map[string]interface{} {
	if w == nil {
		return nil
	}
	return w.GitHubComSync
}

func (w *WorkflowsConfigWorkflow) GetMiniSteps() *MiniStepsSchema {
	if w == nil {
		return nil
	}
	return w.MiniSteps
}

func (w *WorkflowsConfigWorkflow) GetApprovers() []string {
	if w == nil {
		return nil
	}
	return w.Approvers
}

func (w *WorkflowsConfigWorkflow) GetNumberOfApprovalsRequired() *int {
	if w == nil {
		return nil
	}
	return w.NumberOfApprovalsRequired
}

func (w *WorkflowsConfigWorkflow) GetRunnerConstraints() *RunnerConstraints {
	if w == nil {
		return nil
	}
	return w.RunnerConstraints
}

func (w *WorkflowsConfigWorkflow) GetUserJobCpu() *int {
	if w == nil {
		return nil
	}
	return w.UserJobCpu
}

func (w *WorkflowsConfigWorkflow) GetUserJobMemory() *int {
	if w == nil {
		return nil
	}
	return w.UserJobMemory
}

func (w *WorkflowsConfigWorkflow) GetCacheConfig() *CacheConfig {
	if w == nil {
		return nil
	}
	return w.CacheConfig
}

func (w *WorkflowsConfigWorkflow) GetTfStateCleaned() map[string]interface{} {
	if w == nil {
		return nil
	}
	return w.TfStateCleaned
}

func (w *WorkflowsConfigWorkflow) GetInfracostBreakdown() map[string]interface{} {
	if w == nil {
		return nil
	}
	return w.InfracostBreakdown
}

func (w *WorkflowsConfigWorkflow) GetPolicyEvalResults() map[string]interface{} {
	if w == nil {
		return nil
	}
	return w.PolicyEvalResults
}

func (w *WorkflowsConfigWorkflow) GetInfracostBreakdownPreApply() map[string]interface{} {
	if w == nil {
		return nil
	}
	return w.InfracostBreakdownPreApply
}

func (w *WorkflowsConfigWorkflow) GetInfracostBreakdownPostApply() map[string]interface{} {
	if w == nil {
		return nil
	}
	return w.InfracostBreakdownPostApply
}

func (w *WorkflowsConfigWorkflow) GetTfDrift() map[string]interface{} {
	if w == nil {
		return nil
	}
	return w.TfDrift
}

func (w *WorkflowsConfigWorkflow) GetCfStateCleaned() map[string]interface{} {
	if w == nil {
		return nil
	}
	return w.CfStateCleaned
}

func (w *WorkflowsConfigWorkflow) GetCfStackPlan() map[string]interface{} {
	if w == nil {
		return nil
	}
	return w.CfStackPlan
}

func (w *WorkflowsConfigWorkflow) GetCfDrift() map[string]interface{} {
	if w == nil {
		return nil
	}
	return w.CfDrift
}

func (w *WorkflowsConfigWorkflow) GetK8SResources() map[string]interface{} {
	if w == nil {
		return nil
	}
	return w.K8SResources
}

func (w *WorkflowsConfigWorkflow) GetK8SDrift() map[string]interface{} {
	if w == nil {
		return nil
	}
	return w.K8SDrift
}

func (w *WorkflowsConfigWorkflow) GetTerragruntDrift() map[string]interface{} {
	if w == nil {
		return nil
	}
	return w.TerragruntDrift
}

func (w *WorkflowsConfigWorkflow) GetAnsibleOutputs() map[string]interface{} {
	if w == nil {
		return nil
	}
	return w.AnsibleOutputs
}

func (w *WorkflowsConfigWorkflow) GetAnsiblePlan() map[string]interface{} {
	if w == nil {
		return nil
	}
	return w.AnsiblePlan
}

func (w *WorkflowsConfigWorkflow) GetAnsibleDrift() map[string]interface{} {
	if w == nil {
		return nil
	}
	return w.AnsibleDrift
}

func (w *WorkflowsConfigWorkflow) GetBicepResources() map[string]interface{} {
	if w == nil {
		return nil
	}
	return w.BicepResources
}

func (w *WorkflowsConfigWorkflow) GetSgCustomWorkflowRunFacts() map[string]interface{} {
	if w == nil {
		return nil
	}
	return w.SgCustomWorkflowRunFacts
}

func (w *WorkflowsConfigWorkflow) GetContextTags() map[string]*string {
	if w == nil {
		return nil
	}
	return w.ContextTags
}

func (w *WorkflowsConfigWorkflow) GetId() *string {
	if w == nil {
		return nil
	}
	return w.Id
}

func (w *WorkflowsConfigWorkflow) GetTemplateId() *string {
	if w == nil {
		return nil
	}
	return w.TemplateId
}

func (w *WorkflowsConfigWorkflow) GetIacInputData() *TemplatesIacInputData {
	if w == nil {
		return nil
	}
	return w.IacInputData
}

func (w *WorkflowsConfigWorkflow) GetInputSchemas() []*InputSchemas {
	if w == nil {
		return nil
	}
	return w.InputSchemas
}

func (w *WorkflowsConfigWorkflow) GetExtraProperties() map[string]interface{} {
	return w.extraProperties
}

func (w *WorkflowsConfigWorkflow) UnmarshalJSON(data []byte) error {
	type unmarshaler WorkflowsConfigWorkflow
	var value unmarshaler
	if err := json.Unmarshal(data, &value); err != nil {
		return err
	}
	*w = WorkflowsConfigWorkflow(value)
	extraProperties, err := internal.ExtractExtraProperties(data, *w)
	if err != nil {
		return err
	}
	w.extraProperties = extraProperties
	w.rawJSON = json.RawMessage(data)
	return nil
}

func (w *WorkflowsConfigWorkflow) String() string {
	if len(w.rawJSON) > 0 {
		if value, err := internal.StringifyJSON(w.rawJSON); err == nil {
			return value
		}
	}
	if value, err := internal.StringifyJSON(w); err == nil {
		return value
	}
	return fmt.Sprintf("%#v", w)
}

type WorkflowsListAll struct {
	Lastevaluatedkey string                          `json:"lastevaluatedkey" url:"lastevaluatedkey"`
	Msg              []*GeneratedWorkflowsListAllMsg `json:"msg,omitempty" url:"msg,omitempty"`

	extraProperties map[string]interface{}
	rawJSON         json.RawMessage
}

func (w *WorkflowsListAll) GetLastevaluatedkey() string {
	if w == nil {
		return ""
	}
	return w.Lastevaluatedkey
}

func (w *WorkflowsListAll) GetMsg() []*GeneratedWorkflowsListAllMsg {
	if w == nil {
		return nil
	}
	return w.Msg
}

func (w *WorkflowsListAll) GetExtraProperties() map[string]interface{} {
	return w.extraProperties
}

func (w *WorkflowsListAll) UnmarshalJSON(data []byte) error {
	type unmarshaler WorkflowsListAll
	var value unmarshaler
	if err := json.Unmarshal(data, &value); err != nil {
		return err
	}
	*w = WorkflowsListAll(value)
	extraProperties, err := internal.ExtractExtraProperties(data, *w)
	if err != nil {
		return err
	}
	w.extraProperties = extraProperties
	w.rawJSON = json.RawMessage(data)
	return nil
}

func (w *WorkflowsListAll) String() string {
	if len(w.rawJSON) > 0 {
		if value, err := internal.StringifyJSON(w.rawJSON); err == nil {
			return value
		}
	}
	if value, err := internal.StringifyJSON(w); err == nil {
		return value
	}
	return fmt.Sprintf("%#v", w)
}