stepfunctions

package
v0.61.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: May 9, 2023 License: Apache-2.0 Imports: 7 Imported by: 0

Documentation

Index

Constants

View Source 
const (
	StateMachineLoggingConfigurationLevelAll   = StateMachineLoggingConfigurationLevel("ALL")
	StateMachineLoggingConfigurationLevelError = StateMachineLoggingConfigurationLevel("ERROR")
	StateMachineLoggingConfigurationLevelFatal = StateMachineLoggingConfigurationLevel("FATAL")
	StateMachineLoggingConfigurationLevelOff   = StateMachineLoggingConfigurationLevel("OFF")
)
View Source 
const (
	StateMachineTypeStandard = StateMachineType("STANDARD")
	StateMachineTypeExpress  = StateMachineType("EXPRESS")
)

Variables

This section is empty.

Functions

This section is empty.

Types

type Activity 

type Activity struct {
	pulumi.CustomResourceState

	Arn  pulumi.StringOutput          `pulumi:"arn"`
	Name pulumi.StringOutput          `pulumi:"name"`
	Tags ActivityTagsEntryArrayOutput `pulumi:"tags"`
}

Resource schema for Activity

func GetActivity 

func GetActivity(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *ActivityState, opts ...pulumi.ResourceOption) (*Activity, error)

GetActivity gets an existing Activity resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewActivity 

func NewActivity(ctx *pulumi.Context,
	name string, args *ActivityArgs, opts ...pulumi.ResourceOption) (*Activity, error)

NewActivity registers a new resource with the given unique name, arguments, and options.

func (*Activity) ElementType 

func (*Activity) ElementType() reflect.Type

func (*Activity) ToActivityOutput 

func (i *Activity) ToActivityOutput() ActivityOutput

func (*Activity) ToActivityOutputWithContext 

func (i *Activity) ToActivityOutputWithContext(ctx context.Context) ActivityOutput

type ActivityArgs 

type ActivityArgs struct {
	Name pulumi.StringPtrInput
	Tags ActivityTagsEntryArrayInput
}

The set of arguments for constructing a Activity resource.

func (ActivityArgs) ElementType 

func (ActivityArgs) ElementType() reflect.Type

type ActivityInput 

type ActivityInput interface {
	pulumi.Input

	ToActivityOutput() ActivityOutput
	ToActivityOutputWithContext(ctx context.Context) ActivityOutput
}

type ActivityOutput 

type ActivityOutput struct{ *pulumi.OutputState }

func (ActivityOutput) Arn added in v0.17.0 

func (o ActivityOutput) Arn() pulumi.StringOutput

func (ActivityOutput) ElementType 

func (ActivityOutput) ElementType() reflect.Type

func (ActivityOutput) Name added in v0.17.0 

func (o ActivityOutput) Name() pulumi.StringOutput

func (ActivityOutput) Tags added in v0.17.0 

func (o ActivityOutput) Tags() ActivityTagsEntryArrayOutput

func (ActivityOutput) ToActivityOutput 

func (o ActivityOutput) ToActivityOutput() ActivityOutput

func (ActivityOutput) ToActivityOutputWithContext 

func (o ActivityOutput) ToActivityOutputWithContext(ctx context.Context) ActivityOutput

type ActivityState 

type ActivityState struct {
}

func (ActivityState) ElementType 

func (ActivityState) ElementType() reflect.Type

type ActivityTagsEntry 

type ActivityTagsEntry struct {
	Key   string `pulumi:"key"`
	Value string `pulumi:"value"`
}

type ActivityTagsEntryArgs 

type ActivityTagsEntryArgs struct {
	Key   pulumi.StringInput `pulumi:"key"`
	Value pulumi.StringInput `pulumi:"value"`
}

func (ActivityTagsEntryArgs) ElementType 

func (ActivityTagsEntryArgs) ElementType() reflect.Type

func (ActivityTagsEntryArgs) ToActivityTagsEntryOutput 

func (i ActivityTagsEntryArgs) ToActivityTagsEntryOutput() ActivityTagsEntryOutput

func (ActivityTagsEntryArgs) ToActivityTagsEntryOutputWithContext 

func (i ActivityTagsEntryArgs) ToActivityTagsEntryOutputWithContext(ctx context.Context) ActivityTagsEntryOutput

type ActivityTagsEntryArray 

type ActivityTagsEntryArray []ActivityTagsEntryInput

func (ActivityTagsEntryArray) ElementType 

func (ActivityTagsEntryArray) ElementType() reflect.Type

func (ActivityTagsEntryArray) ToActivityTagsEntryArrayOutput 

func (i ActivityTagsEntryArray) ToActivityTagsEntryArrayOutput() ActivityTagsEntryArrayOutput

func (ActivityTagsEntryArray) ToActivityTagsEntryArrayOutputWithContext 

func (i ActivityTagsEntryArray) ToActivityTagsEntryArrayOutputWithContext(ctx context.Context) ActivityTagsEntryArrayOutput

type ActivityTagsEntryArrayInput 

type ActivityTagsEntryArrayInput interface {
	pulumi.Input

	ToActivityTagsEntryArrayOutput() ActivityTagsEntryArrayOutput
	ToActivityTagsEntryArrayOutputWithContext(context.Context) ActivityTagsEntryArrayOutput
}

ActivityTagsEntryArrayInput is an input type that accepts ActivityTagsEntryArray and ActivityTagsEntryArrayOutput values. You can construct a concrete instance of `ActivityTagsEntryArrayInput` via: 

ActivityTagsEntryArray{ ActivityTagsEntryArgs{...} }

type ActivityTagsEntryArrayOutput 

type ActivityTagsEntryArrayOutput struct{ *pulumi.OutputState }

func (ActivityTagsEntryArrayOutput) ElementType 

func (ActivityTagsEntryArrayOutput) ElementType() reflect.Type

func (ActivityTagsEntryArrayOutput) Index 

func (o ActivityTagsEntryArrayOutput) Index(i pulumi.IntInput) ActivityTagsEntryOutput

func (ActivityTagsEntryArrayOutput) ToActivityTagsEntryArrayOutput 

func (o ActivityTagsEntryArrayOutput) ToActivityTagsEntryArrayOutput() ActivityTagsEntryArrayOutput

func (ActivityTagsEntryArrayOutput) ToActivityTagsEntryArrayOutputWithContext 

func (o ActivityTagsEntryArrayOutput) ToActivityTagsEntryArrayOutputWithContext(ctx context.Context) ActivityTagsEntryArrayOutput

type ActivityTagsEntryInput 

type ActivityTagsEntryInput interface {
	pulumi.Input

	ToActivityTagsEntryOutput() ActivityTagsEntryOutput
	ToActivityTagsEntryOutputWithContext(context.Context) ActivityTagsEntryOutput
}

ActivityTagsEntryInput is an input type that accepts ActivityTagsEntryArgs and ActivityTagsEntryOutput values. You can construct a concrete instance of `ActivityTagsEntryInput` via: 

ActivityTagsEntryArgs{...}

type ActivityTagsEntryOutput 

type ActivityTagsEntryOutput struct{ *pulumi.OutputState }

func (ActivityTagsEntryOutput) ElementType 

func (ActivityTagsEntryOutput) ElementType() reflect.Type

func (ActivityTagsEntryOutput) Key 

func (o ActivityTagsEntryOutput) Key() pulumi.StringOutput

func (ActivityTagsEntryOutput) ToActivityTagsEntryOutput 

func (o ActivityTagsEntryOutput) ToActivityTagsEntryOutput() ActivityTagsEntryOutput

func (ActivityTagsEntryOutput) ToActivityTagsEntryOutputWithContext 

func (o ActivityTagsEntryOutput) ToActivityTagsEntryOutputWithContext(ctx context.Context) ActivityTagsEntryOutput

func (ActivityTagsEntryOutput) Value 

func (o ActivityTagsEntryOutput) Value() pulumi.StringOutput

type LookupActivityArgs added in v0.12.0 

type LookupActivityArgs struct {
	Arn string `pulumi:"arn"`
}

type LookupActivityOutputArgs added in v0.12.0 

type LookupActivityOutputArgs struct {
	Arn pulumi.StringInput `pulumi:"arn"`
}

func (LookupActivityOutputArgs) ElementType added in v0.12.0 

func (LookupActivityOutputArgs) ElementType() reflect.Type

type LookupActivityResult added in v0.12.0 

type LookupActivityResult struct {
	Arn  *string             `pulumi:"arn"`
	Tags []ActivityTagsEntry `pulumi:"tags"`
}

func LookupActivity added in v0.12.0 

func LookupActivity(ctx *pulumi.Context, args *LookupActivityArgs, opts ...pulumi.InvokeOption) (*LookupActivityResult, error)

Resource schema for Activity

type LookupActivityResultOutput added in v0.12.0 

type LookupActivityResultOutput struct{ *pulumi.OutputState }

func LookupActivityOutput added in v0.12.0 

func LookupActivityOutput(ctx *pulumi.Context, args LookupActivityOutputArgs, opts ...pulumi.InvokeOption) LookupActivityResultOutput

func (LookupActivityResultOutput) Arn added in v0.12.0 

func (o LookupActivityResultOutput) Arn() pulumi.StringPtrOutput

func (LookupActivityResultOutput) ElementType added in v0.12.0 

func (LookupActivityResultOutput) ElementType() reflect.Type

func (LookupActivityResultOutput) Tags added in v0.12.0 

func (o LookupActivityResultOutput) Tags() ActivityTagsEntryArrayOutput

func (LookupActivityResultOutput) ToLookupActivityResultOutput added in v0.12.0 

func (o LookupActivityResultOutput) ToLookupActivityResultOutput() LookupActivityResultOutput

func (LookupActivityResultOutput) ToLookupActivityResultOutputWithContext added in v0.12.0 

func (o LookupActivityResultOutput) ToLookupActivityResultOutputWithContext(ctx context.Context) LookupActivityResultOutput

type LookupStateMachineArgs added in v0.12.0 

type LookupStateMachineArgs struct {
	Arn string `pulumi:"arn"`
}

type LookupStateMachineOutputArgs added in v0.12.0 

type LookupStateMachineOutputArgs struct {
	Arn pulumi.StringInput `pulumi:"arn"`
}

func (LookupStateMachineOutputArgs) ElementType added in v0.12.0 

func (LookupStateMachineOutputArgs) ElementType() reflect.Type

type LookupStateMachineResult added in v0.12.0 

type LookupStateMachineResult struct {
	Arn                    *string                           `pulumi:"arn"`
	DefinitionString       *string                           `pulumi:"definitionString"`
	LoggingConfiguration   *StateMachineLoggingConfiguration `pulumi:"loggingConfiguration"`
	Name                   *string                           `pulumi:"name"`
	RoleArn                *string                           `pulumi:"roleArn"`
	StateMachineRevisionId *string                           `pulumi:"stateMachineRevisionId"`
	Tags                   []StateMachineTagsEntry           `pulumi:"tags"`
	TracingConfiguration   *StateMachineTracingConfiguration `pulumi:"tracingConfiguration"`
}

func LookupStateMachine added in v0.12.0 

func LookupStateMachine(ctx *pulumi.Context, args *LookupStateMachineArgs, opts ...pulumi.InvokeOption) (*LookupStateMachineResult, error)

Resource schema for StateMachine

type LookupStateMachineResultOutput added in v0.12.0 

type LookupStateMachineResultOutput struct{ *pulumi.OutputState }

func LookupStateMachineOutput added in v0.12.0 

func LookupStateMachineOutput(ctx *pulumi.Context, args LookupStateMachineOutputArgs, opts ...pulumi.InvokeOption) LookupStateMachineResultOutput

func (LookupStateMachineResultOutput) Arn added in v0.12.0 

func (o LookupStateMachineResultOutput) Arn() pulumi.StringPtrOutput

func (LookupStateMachineResultOutput) DefinitionString added in v0.12.0 

func (o LookupStateMachineResultOutput) DefinitionString() pulumi.StringPtrOutput

func (LookupStateMachineResultOutput) ElementType added in v0.12.0 

func (LookupStateMachineResultOutput) ElementType() reflect.Type

func (LookupStateMachineResultOutput) LoggingConfiguration added in v0.12.0 

func (o LookupStateMachineResultOutput) LoggingConfiguration() StateMachineLoggingConfigurationPtrOutput

func (LookupStateMachineResultOutput) Name added in v0.12.0 

func (o LookupStateMachineResultOutput) Name() pulumi.StringPtrOutput

func (LookupStateMachineResultOutput) RoleArn added in v0.12.0 

func (o LookupStateMachineResultOutput) RoleArn() pulumi.StringPtrOutput

func (LookupStateMachineResultOutput) StateMachineRevisionId added in v0.54.0 

func (o LookupStateMachineResultOutput) StateMachineRevisionId() pulumi.StringPtrOutput

func (LookupStateMachineResultOutput) Tags added in v0.12.0 

func (o LookupStateMachineResultOutput) Tags() StateMachineTagsEntryArrayOutput

func (LookupStateMachineResultOutput) ToLookupStateMachineResultOutput added in v0.12.0 

func (o LookupStateMachineResultOutput) ToLookupStateMachineResultOutput() LookupStateMachineResultOutput

func (LookupStateMachineResultOutput) ToLookupStateMachineResultOutputWithContext added in v0.12.0 

func (o LookupStateMachineResultOutput) ToLookupStateMachineResultOutputWithContext(ctx context.Context) LookupStateMachineResultOutput

func (LookupStateMachineResultOutput) TracingConfiguration added in v0.12.0 

func (o LookupStateMachineResultOutput) TracingConfiguration() StateMachineTracingConfigurationPtrOutput

type StateMachine 

type StateMachine struct {
	pulumi.CustomResourceState

	Arn                     pulumi.StringOutput                          `pulumi:"arn"`
	Definition              StateMachineDefinitionPtrOutput              `pulumi:"definition"`
	DefinitionS3Location    StateMachineS3LocationPtrOutput              `pulumi:"definitionS3Location"`
	DefinitionString        pulumi.StringPtrOutput                       `pulumi:"definitionString"`
	DefinitionSubstitutions StateMachineDefinitionSubstitutionsPtrOutput `pulumi:"definitionSubstitutions"`
	LoggingConfiguration    StateMachineLoggingConfigurationPtrOutput    `pulumi:"loggingConfiguration"`
	Name                    pulumi.StringOutput                          `pulumi:"name"`
	RoleArn                 pulumi.StringOutput                          `pulumi:"roleArn"`
	StateMachineName        pulumi.StringPtrOutput                       `pulumi:"stateMachineName"`
	StateMachineRevisionId  pulumi.StringOutput                          `pulumi:"stateMachineRevisionId"`
	StateMachineType        StateMachineTypePtrOutput                    `pulumi:"stateMachineType"`
	Tags                    StateMachineTagsEntryArrayOutput             `pulumi:"tags"`
	TracingConfiguration    StateMachineTracingConfigurationPtrOutput    `pulumi:"tracingConfiguration"`
}

Resource schema for StateMachine

func GetStateMachine 

func GetStateMachine(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *StateMachineState, opts ...pulumi.ResourceOption) (*StateMachine, error)

GetStateMachine gets an existing StateMachine resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewStateMachine 

func NewStateMachine(ctx *pulumi.Context,
	name string, args *StateMachineArgs, opts ...pulumi.ResourceOption) (*StateMachine, error)

NewStateMachine registers a new resource with the given unique name, arguments, and options.

func (*StateMachine) ElementType 

func (*StateMachine) ElementType() reflect.Type

func (*StateMachine) ToStateMachineOutput 

func (i *StateMachine) ToStateMachineOutput() StateMachineOutput

func (*StateMachine) ToStateMachineOutputWithContext 

func (i *StateMachine) ToStateMachineOutputWithContext(ctx context.Context) StateMachineOutput

type StateMachineArgs 

type StateMachineArgs struct {
	Definition              StateMachineDefinitionPtrInput
	DefinitionS3Location    StateMachineS3LocationPtrInput
	DefinitionString        pulumi.StringPtrInput
	DefinitionSubstitutions StateMachineDefinitionSubstitutionsPtrInput
	LoggingConfiguration    StateMachineLoggingConfigurationPtrInput
	RoleArn                 pulumi.StringInput
	StateMachineName        pulumi.StringPtrInput
	StateMachineType        StateMachineTypePtrInput
	Tags                    StateMachineTagsEntryArrayInput
	TracingConfiguration    StateMachineTracingConfigurationPtrInput
}

The set of arguments for constructing a StateMachine resource.

func (StateMachineArgs) ElementType 

func (StateMachineArgs) ElementType() reflect.Type

type StateMachineCloudWatchLogsLogGroup 

type StateMachineCloudWatchLogsLogGroup struct {
	LogGroupArn *string `pulumi:"logGroupArn"`
}

type StateMachineCloudWatchLogsLogGroupArgs 

type StateMachineCloudWatchLogsLogGroupArgs struct {
	LogGroupArn pulumi.StringPtrInput `pulumi:"logGroupArn"`
}

func (StateMachineCloudWatchLogsLogGroupArgs) ElementType 

func (StateMachineCloudWatchLogsLogGroupArgs) ElementType() reflect.Type

func (StateMachineCloudWatchLogsLogGroupArgs) ToStateMachineCloudWatchLogsLogGroupOutput 

func (i StateMachineCloudWatchLogsLogGroupArgs) ToStateMachineCloudWatchLogsLogGroupOutput() StateMachineCloudWatchLogsLogGroupOutput

func (StateMachineCloudWatchLogsLogGroupArgs) ToStateMachineCloudWatchLogsLogGroupOutputWithContext 

func (i StateMachineCloudWatchLogsLogGroupArgs) ToStateMachineCloudWatchLogsLogGroupOutputWithContext(ctx context.Context) StateMachineCloudWatchLogsLogGroupOutput

func (StateMachineCloudWatchLogsLogGroupArgs) ToStateMachineCloudWatchLogsLogGroupPtrOutput 

func (i StateMachineCloudWatchLogsLogGroupArgs) ToStateMachineCloudWatchLogsLogGroupPtrOutput() StateMachineCloudWatchLogsLogGroupPtrOutput

func (StateMachineCloudWatchLogsLogGroupArgs) ToStateMachineCloudWatchLogsLogGroupPtrOutputWithContext 

func (i StateMachineCloudWatchLogsLogGroupArgs) ToStateMachineCloudWatchLogsLogGroupPtrOutputWithContext(ctx context.Context) StateMachineCloudWatchLogsLogGroupPtrOutput

type StateMachineCloudWatchLogsLogGroupInput 

type StateMachineCloudWatchLogsLogGroupInput interface {
	pulumi.Input

	ToStateMachineCloudWatchLogsLogGroupOutput() StateMachineCloudWatchLogsLogGroupOutput
	ToStateMachineCloudWatchLogsLogGroupOutputWithContext(context.Context) StateMachineCloudWatchLogsLogGroupOutput
}

StateMachineCloudWatchLogsLogGroupInput is an input type that accepts StateMachineCloudWatchLogsLogGroupArgs and StateMachineCloudWatchLogsLogGroupOutput values. You can construct a concrete instance of `StateMachineCloudWatchLogsLogGroupInput` via: 

StateMachineCloudWatchLogsLogGroupArgs{...}

type StateMachineCloudWatchLogsLogGroupOutput 

type StateMachineCloudWatchLogsLogGroupOutput struct{ *pulumi.OutputState }

func (StateMachineCloudWatchLogsLogGroupOutput) ElementType 

func (StateMachineCloudWatchLogsLogGroupOutput) ElementType() reflect.Type

func (StateMachineCloudWatchLogsLogGroupOutput) LogGroupArn 

func (o StateMachineCloudWatchLogsLogGroupOutput) LogGroupArn() pulumi.StringPtrOutput

func (StateMachineCloudWatchLogsLogGroupOutput) ToStateMachineCloudWatchLogsLogGroupOutput 

func (o StateMachineCloudWatchLogsLogGroupOutput) ToStateMachineCloudWatchLogsLogGroupOutput() StateMachineCloudWatchLogsLogGroupOutput

func (StateMachineCloudWatchLogsLogGroupOutput) ToStateMachineCloudWatchLogsLogGroupOutputWithContext 

func (o StateMachineCloudWatchLogsLogGroupOutput) ToStateMachineCloudWatchLogsLogGroupOutputWithContext(ctx context.Context) StateMachineCloudWatchLogsLogGroupOutput

func (StateMachineCloudWatchLogsLogGroupOutput) ToStateMachineCloudWatchLogsLogGroupPtrOutput 

func (o StateMachineCloudWatchLogsLogGroupOutput) ToStateMachineCloudWatchLogsLogGroupPtrOutput() StateMachineCloudWatchLogsLogGroupPtrOutput

func (StateMachineCloudWatchLogsLogGroupOutput) ToStateMachineCloudWatchLogsLogGroupPtrOutputWithContext 

func (o StateMachineCloudWatchLogsLogGroupOutput) ToStateMachineCloudWatchLogsLogGroupPtrOutputWithContext(ctx context.Context) StateMachineCloudWatchLogsLogGroupPtrOutput

type StateMachineCloudWatchLogsLogGroupPtrInput 

type StateMachineCloudWatchLogsLogGroupPtrInput interface {
	pulumi.Input

	ToStateMachineCloudWatchLogsLogGroupPtrOutput() StateMachineCloudWatchLogsLogGroupPtrOutput
	ToStateMachineCloudWatchLogsLogGroupPtrOutputWithContext(context.Context) StateMachineCloudWatchLogsLogGroupPtrOutput
}

StateMachineCloudWatchLogsLogGroupPtrInput is an input type that accepts StateMachineCloudWatchLogsLogGroupArgs, StateMachineCloudWatchLogsLogGroupPtr and StateMachineCloudWatchLogsLogGroupPtrOutput values. You can construct a concrete instance of `StateMachineCloudWatchLogsLogGroupPtrInput` via: 

        StateMachineCloudWatchLogsLogGroupArgs{...}

or:

        nil

func StateMachineCloudWatchLogsLogGroupPtr 

func StateMachineCloudWatchLogsLogGroupPtr(v *StateMachineCloudWatchLogsLogGroupArgs) StateMachineCloudWatchLogsLogGroupPtrInput

type StateMachineCloudWatchLogsLogGroupPtrOutput 

type StateMachineCloudWatchLogsLogGroupPtrOutput struct{ *pulumi.OutputState }

func (StateMachineCloudWatchLogsLogGroupPtrOutput) Elem 

func (o StateMachineCloudWatchLogsLogGroupPtrOutput) Elem() StateMachineCloudWatchLogsLogGroupOutput

func (StateMachineCloudWatchLogsLogGroupPtrOutput) ElementType 

func (StateMachineCloudWatchLogsLogGroupPtrOutput) ElementType() reflect.Type

func (StateMachineCloudWatchLogsLogGroupPtrOutput) LogGroupArn 

func (o StateMachineCloudWatchLogsLogGroupPtrOutput) LogGroupArn() pulumi.StringPtrOutput

func (StateMachineCloudWatchLogsLogGroupPtrOutput) ToStateMachineCloudWatchLogsLogGroupPtrOutput 

func (o StateMachineCloudWatchLogsLogGroupPtrOutput) ToStateMachineCloudWatchLogsLogGroupPtrOutput() StateMachineCloudWatchLogsLogGroupPtrOutput

func (StateMachineCloudWatchLogsLogGroupPtrOutput) ToStateMachineCloudWatchLogsLogGroupPtrOutputWithContext 

func (o StateMachineCloudWatchLogsLogGroupPtrOutput) ToStateMachineCloudWatchLogsLogGroupPtrOutputWithContext(ctx context.Context) StateMachineCloudWatchLogsLogGroupPtrOutput

type StateMachineDefinition 

type StateMachineDefinition struct {
}

type StateMachineDefinitionArgs 

type StateMachineDefinitionArgs struct {
}

func (StateMachineDefinitionArgs) ElementType 

func (StateMachineDefinitionArgs) ElementType() reflect.Type

func (StateMachineDefinitionArgs) ToStateMachineDefinitionOutput 

func (i StateMachineDefinitionArgs) ToStateMachineDefinitionOutput() StateMachineDefinitionOutput

func (StateMachineDefinitionArgs) ToStateMachineDefinitionOutputWithContext 

func (i StateMachineDefinitionArgs) ToStateMachineDefinitionOutputWithContext(ctx context.Context) StateMachineDefinitionOutput

func (StateMachineDefinitionArgs) ToStateMachineDefinitionPtrOutput 

func (i StateMachineDefinitionArgs) ToStateMachineDefinitionPtrOutput() StateMachineDefinitionPtrOutput

func (StateMachineDefinitionArgs) ToStateMachineDefinitionPtrOutputWithContext 

func (i StateMachineDefinitionArgs) ToStateMachineDefinitionPtrOutputWithContext(ctx context.Context) StateMachineDefinitionPtrOutput

type StateMachineDefinitionInput 

type StateMachineDefinitionInput interface {
	pulumi.Input

	ToStateMachineDefinitionOutput() StateMachineDefinitionOutput
	ToStateMachineDefinitionOutputWithContext(context.Context) StateMachineDefinitionOutput
}

StateMachineDefinitionInput is an input type that accepts StateMachineDefinitionArgs and StateMachineDefinitionOutput values. You can construct a concrete instance of `StateMachineDefinitionInput` via: 

StateMachineDefinitionArgs{...}

type StateMachineDefinitionOutput 

type StateMachineDefinitionOutput struct{ *pulumi.OutputState }

func (StateMachineDefinitionOutput) ElementType 

func (StateMachineDefinitionOutput) ElementType() reflect.Type

func (StateMachineDefinitionOutput) ToStateMachineDefinitionOutput 

func (o StateMachineDefinitionOutput) ToStateMachineDefinitionOutput() StateMachineDefinitionOutput

func (StateMachineDefinitionOutput) ToStateMachineDefinitionOutputWithContext 

func (o StateMachineDefinitionOutput) ToStateMachineDefinitionOutputWithContext(ctx context.Context) StateMachineDefinitionOutput

func (StateMachineDefinitionOutput) ToStateMachineDefinitionPtrOutput 

func (o StateMachineDefinitionOutput) ToStateMachineDefinitionPtrOutput() StateMachineDefinitionPtrOutput

func (StateMachineDefinitionOutput) ToStateMachineDefinitionPtrOutputWithContext 

func (o StateMachineDefinitionOutput) ToStateMachineDefinitionPtrOutputWithContext(ctx context.Context) StateMachineDefinitionPtrOutput

type StateMachineDefinitionPtrInput 

type StateMachineDefinitionPtrInput interface {
	pulumi.Input

	ToStateMachineDefinitionPtrOutput() StateMachineDefinitionPtrOutput
	ToStateMachineDefinitionPtrOutputWithContext(context.Context) StateMachineDefinitionPtrOutput
}

StateMachineDefinitionPtrInput is an input type that accepts StateMachineDefinitionArgs, StateMachineDefinitionPtr and StateMachineDefinitionPtrOutput values. You can construct a concrete instance of `StateMachineDefinitionPtrInput` via: 

        StateMachineDefinitionArgs{...}

or:

        nil

func StateMachineDefinitionPtr 

func StateMachineDefinitionPtr(v *StateMachineDefinitionArgs) StateMachineDefinitionPtrInput

type StateMachineDefinitionPtrOutput 

type StateMachineDefinitionPtrOutput struct{ *pulumi.OutputState }

func (StateMachineDefinitionPtrOutput) Elem 

func (o StateMachineDefinitionPtrOutput) Elem() StateMachineDefinitionOutput

func (StateMachineDefinitionPtrOutput) ElementType 

func (StateMachineDefinitionPtrOutput) ElementType() reflect.Type

func (StateMachineDefinitionPtrOutput) ToStateMachineDefinitionPtrOutput 

func (o StateMachineDefinitionPtrOutput) ToStateMachineDefinitionPtrOutput() StateMachineDefinitionPtrOutput

func (StateMachineDefinitionPtrOutput) ToStateMachineDefinitionPtrOutputWithContext 

func (o StateMachineDefinitionPtrOutput) ToStateMachineDefinitionPtrOutputWithContext(ctx context.Context) StateMachineDefinitionPtrOutput

type StateMachineDefinitionSubstitutions 

type StateMachineDefinitionSubstitutions struct {
}

type StateMachineDefinitionSubstitutionsArgs 

type StateMachineDefinitionSubstitutionsArgs struct {
}

func (StateMachineDefinitionSubstitutionsArgs) ElementType 

func (StateMachineDefinitionSubstitutionsArgs) ElementType() reflect.Type

func (StateMachineDefinitionSubstitutionsArgs) ToStateMachineDefinitionSubstitutionsOutput 

func (i StateMachineDefinitionSubstitutionsArgs) ToStateMachineDefinitionSubstitutionsOutput() StateMachineDefinitionSubstitutionsOutput

func (StateMachineDefinitionSubstitutionsArgs) ToStateMachineDefinitionSubstitutionsOutputWithContext 

func (i StateMachineDefinitionSubstitutionsArgs) ToStateMachineDefinitionSubstitutionsOutputWithContext(ctx context.Context) StateMachineDefinitionSubstitutionsOutput

func (StateMachineDefinitionSubstitutionsArgs) ToStateMachineDefinitionSubstitutionsPtrOutput 

func (i StateMachineDefinitionSubstitutionsArgs) ToStateMachineDefinitionSubstitutionsPtrOutput() StateMachineDefinitionSubstitutionsPtrOutput

func (StateMachineDefinitionSubstitutionsArgs) ToStateMachineDefinitionSubstitutionsPtrOutputWithContext 

func (i StateMachineDefinitionSubstitutionsArgs) ToStateMachineDefinitionSubstitutionsPtrOutputWithContext(ctx context.Context) StateMachineDefinitionSubstitutionsPtrOutput

type StateMachineDefinitionSubstitutionsInput 

type StateMachineDefinitionSubstitutionsInput interface {
	pulumi.Input

	ToStateMachineDefinitionSubstitutionsOutput() StateMachineDefinitionSubstitutionsOutput
	ToStateMachineDefinitionSubstitutionsOutputWithContext(context.Context) StateMachineDefinitionSubstitutionsOutput
}

StateMachineDefinitionSubstitutionsInput is an input type that accepts StateMachineDefinitionSubstitutionsArgs and StateMachineDefinitionSubstitutionsOutput values. You can construct a concrete instance of `StateMachineDefinitionSubstitutionsInput` via: 

StateMachineDefinitionSubstitutionsArgs{...}

type StateMachineDefinitionSubstitutionsOutput 

type StateMachineDefinitionSubstitutionsOutput struct{ *pulumi.OutputState }

func (StateMachineDefinitionSubstitutionsOutput) ElementType 

func (StateMachineDefinitionSubstitutionsOutput) ElementType() reflect.Type

func (StateMachineDefinitionSubstitutionsOutput) ToStateMachineDefinitionSubstitutionsOutput 

func (o StateMachineDefinitionSubstitutionsOutput) ToStateMachineDefinitionSubstitutionsOutput() StateMachineDefinitionSubstitutionsOutput

func (StateMachineDefinitionSubstitutionsOutput) ToStateMachineDefinitionSubstitutionsOutputWithContext 

func (o StateMachineDefinitionSubstitutionsOutput) ToStateMachineDefinitionSubstitutionsOutputWithContext(ctx context.Context) StateMachineDefinitionSubstitutionsOutput

func (StateMachineDefinitionSubstitutionsOutput) ToStateMachineDefinitionSubstitutionsPtrOutput 

func (o StateMachineDefinitionSubstitutionsOutput) ToStateMachineDefinitionSubstitutionsPtrOutput() StateMachineDefinitionSubstitutionsPtrOutput

func (StateMachineDefinitionSubstitutionsOutput) ToStateMachineDefinitionSubstitutionsPtrOutputWithContext 

func (o StateMachineDefinitionSubstitutionsOutput) ToStateMachineDefinitionSubstitutionsPtrOutputWithContext(ctx context.Context) StateMachineDefinitionSubstitutionsPtrOutput

type StateMachineDefinitionSubstitutionsPtrInput 

type StateMachineDefinitionSubstitutionsPtrInput interface {
	pulumi.Input

	ToStateMachineDefinitionSubstitutionsPtrOutput() StateMachineDefinitionSubstitutionsPtrOutput
	ToStateMachineDefinitionSubstitutionsPtrOutputWithContext(context.Context) StateMachineDefinitionSubstitutionsPtrOutput
}

StateMachineDefinitionSubstitutionsPtrInput is an input type that accepts StateMachineDefinitionSubstitutionsArgs, StateMachineDefinitionSubstitutionsPtr and StateMachineDefinitionSubstitutionsPtrOutput values. You can construct a concrete instance of `StateMachineDefinitionSubstitutionsPtrInput` via: 

        StateMachineDefinitionSubstitutionsArgs{...}

or:

        nil

func StateMachineDefinitionSubstitutionsPtr 

func StateMachineDefinitionSubstitutionsPtr(v *StateMachineDefinitionSubstitutionsArgs) StateMachineDefinitionSubstitutionsPtrInput

type StateMachineDefinitionSubstitutionsPtrOutput 

type StateMachineDefinitionSubstitutionsPtrOutput struct{ *pulumi.OutputState }

func (StateMachineDefinitionSubstitutionsPtrOutput) Elem 

func (o StateMachineDefinitionSubstitutionsPtrOutput) Elem() StateMachineDefinitionSubstitutionsOutput

func (StateMachineDefinitionSubstitutionsPtrOutput) ElementType 

func (StateMachineDefinitionSubstitutionsPtrOutput) ElementType() reflect.Type

func (StateMachineDefinitionSubstitutionsPtrOutput) ToStateMachineDefinitionSubstitutionsPtrOutput 

func (o StateMachineDefinitionSubstitutionsPtrOutput) ToStateMachineDefinitionSubstitutionsPtrOutput() StateMachineDefinitionSubstitutionsPtrOutput

func (StateMachineDefinitionSubstitutionsPtrOutput) ToStateMachineDefinitionSubstitutionsPtrOutputWithContext 

func (o StateMachineDefinitionSubstitutionsPtrOutput) ToStateMachineDefinitionSubstitutionsPtrOutputWithContext(ctx context.Context) StateMachineDefinitionSubstitutionsPtrOutput

type StateMachineInput 

type StateMachineInput interface {
	pulumi.Input

	ToStateMachineOutput() StateMachineOutput
	ToStateMachineOutputWithContext(ctx context.Context) StateMachineOutput
}

type StateMachineLogDestination 

type StateMachineLogDestination struct {
	CloudWatchLogsLogGroup *StateMachineCloudWatchLogsLogGroup `pulumi:"cloudWatchLogsLogGroup"`
}

type StateMachineLogDestinationArgs 

type StateMachineLogDestinationArgs struct {
	CloudWatchLogsLogGroup StateMachineCloudWatchLogsLogGroupPtrInput `pulumi:"cloudWatchLogsLogGroup"`
}

func (StateMachineLogDestinationArgs) ElementType 

func (StateMachineLogDestinationArgs) ElementType() reflect.Type

func (StateMachineLogDestinationArgs) ToStateMachineLogDestinationOutput 

func (i StateMachineLogDestinationArgs) ToStateMachineLogDestinationOutput() StateMachineLogDestinationOutput

func (StateMachineLogDestinationArgs) ToStateMachineLogDestinationOutputWithContext 

func (i StateMachineLogDestinationArgs) ToStateMachineLogDestinationOutputWithContext(ctx context.Context) StateMachineLogDestinationOutput

type StateMachineLogDestinationArray 

type StateMachineLogDestinationArray []StateMachineLogDestinationInput

func (StateMachineLogDestinationArray) ElementType 

func (StateMachineLogDestinationArray) ElementType() reflect.Type

func (StateMachineLogDestinationArray) ToStateMachineLogDestinationArrayOutput 

func (i StateMachineLogDestinationArray) ToStateMachineLogDestinationArrayOutput() StateMachineLogDestinationArrayOutput

func (StateMachineLogDestinationArray) ToStateMachineLogDestinationArrayOutputWithContext 

func (i StateMachineLogDestinationArray) ToStateMachineLogDestinationArrayOutputWithContext(ctx context.Context) StateMachineLogDestinationArrayOutput

type StateMachineLogDestinationArrayInput 

type StateMachineLogDestinationArrayInput interface {
	pulumi.Input

	ToStateMachineLogDestinationArrayOutput() StateMachineLogDestinationArrayOutput
	ToStateMachineLogDestinationArrayOutputWithContext(context.Context) StateMachineLogDestinationArrayOutput
}

StateMachineLogDestinationArrayInput is an input type that accepts StateMachineLogDestinationArray and StateMachineLogDestinationArrayOutput values. You can construct a concrete instance of `StateMachineLogDestinationArrayInput` via: 

StateMachineLogDestinationArray{ StateMachineLogDestinationArgs{...} }

type StateMachineLogDestinationArrayOutput 

type StateMachineLogDestinationArrayOutput struct{ *pulumi.OutputState }

func (StateMachineLogDestinationArrayOutput) ElementType 

func (StateMachineLogDestinationArrayOutput) ElementType() reflect.Type

func (StateMachineLogDestinationArrayOutput) Index 

func (o StateMachineLogDestinationArrayOutput) Index(i pulumi.IntInput) StateMachineLogDestinationOutput

func (StateMachineLogDestinationArrayOutput) ToStateMachineLogDestinationArrayOutput 

func (o StateMachineLogDestinationArrayOutput) ToStateMachineLogDestinationArrayOutput() StateMachineLogDestinationArrayOutput

func (StateMachineLogDestinationArrayOutput) ToStateMachineLogDestinationArrayOutputWithContext 

func (o StateMachineLogDestinationArrayOutput) ToStateMachineLogDestinationArrayOutputWithContext(ctx context.Context) StateMachineLogDestinationArrayOutput

type StateMachineLogDestinationInput 

type StateMachineLogDestinationInput interface {
	pulumi.Input

	ToStateMachineLogDestinationOutput() StateMachineLogDestinationOutput
	ToStateMachineLogDestinationOutputWithContext(context.Context) StateMachineLogDestinationOutput
}

StateMachineLogDestinationInput is an input type that accepts StateMachineLogDestinationArgs and StateMachineLogDestinationOutput values. You can construct a concrete instance of `StateMachineLogDestinationInput` via: 

StateMachineLogDestinationArgs{...}

type StateMachineLogDestinationOutput 

type StateMachineLogDestinationOutput struct{ *pulumi.OutputState }

func (StateMachineLogDestinationOutput) CloudWatchLogsLogGroup 

func (o StateMachineLogDestinationOutput) CloudWatchLogsLogGroup() StateMachineCloudWatchLogsLogGroupPtrOutput

func (StateMachineLogDestinationOutput) ElementType 

func (StateMachineLogDestinationOutput) ElementType() reflect.Type

func (StateMachineLogDestinationOutput) ToStateMachineLogDestinationOutput 

func (o StateMachineLogDestinationOutput) ToStateMachineLogDestinationOutput() StateMachineLogDestinationOutput

func (StateMachineLogDestinationOutput) ToStateMachineLogDestinationOutputWithContext 

func (o StateMachineLogDestinationOutput) ToStateMachineLogDestinationOutputWithContext(ctx context.Context) StateMachineLogDestinationOutput

type StateMachineLoggingConfiguration 

type StateMachineLoggingConfiguration struct {
	Destinations         []StateMachineLogDestination           `pulumi:"destinations"`
	IncludeExecutionData *bool                                  `pulumi:"includeExecutionData"`
	Level                *StateMachineLoggingConfigurationLevel `pulumi:"level"`
}

type StateMachineLoggingConfigurationArgs 

type StateMachineLoggingConfigurationArgs struct {
	Destinations         StateMachineLogDestinationArrayInput          `pulumi:"destinations"`
	IncludeExecutionData pulumi.BoolPtrInput                           `pulumi:"includeExecutionData"`
	Level                StateMachineLoggingConfigurationLevelPtrInput `pulumi:"level"`
}

func (StateMachineLoggingConfigurationArgs) ElementType 

func (StateMachineLoggingConfigurationArgs) ElementType() reflect.Type

func (StateMachineLoggingConfigurationArgs) ToStateMachineLoggingConfigurationOutput 

func (i StateMachineLoggingConfigurationArgs) ToStateMachineLoggingConfigurationOutput() StateMachineLoggingConfigurationOutput

func (StateMachineLoggingConfigurationArgs) ToStateMachineLoggingConfigurationOutputWithContext 

func (i StateMachineLoggingConfigurationArgs) ToStateMachineLoggingConfigurationOutputWithContext(ctx context.Context) StateMachineLoggingConfigurationOutput

func (StateMachineLoggingConfigurationArgs) ToStateMachineLoggingConfigurationPtrOutput 

func (i StateMachineLoggingConfigurationArgs) ToStateMachineLoggingConfigurationPtrOutput() StateMachineLoggingConfigurationPtrOutput

func (StateMachineLoggingConfigurationArgs) ToStateMachineLoggingConfigurationPtrOutputWithContext 

func (i StateMachineLoggingConfigurationArgs) ToStateMachineLoggingConfigurationPtrOutputWithContext(ctx context.Context) StateMachineLoggingConfigurationPtrOutput

type StateMachineLoggingConfigurationInput 

type StateMachineLoggingConfigurationInput interface {
	pulumi.Input

	ToStateMachineLoggingConfigurationOutput() StateMachineLoggingConfigurationOutput
	ToStateMachineLoggingConfigurationOutputWithContext(context.Context) StateMachineLoggingConfigurationOutput
}

StateMachineLoggingConfigurationInput is an input type that accepts StateMachineLoggingConfigurationArgs and StateMachineLoggingConfigurationOutput values. You can construct a concrete instance of `StateMachineLoggingConfigurationInput` via: 

StateMachineLoggingConfigurationArgs{...}

type StateMachineLoggingConfigurationLevel 

type StateMachineLoggingConfigurationLevel string

func (StateMachineLoggingConfigurationLevel) ElementType 

func (StateMachineLoggingConfigurationLevel) ElementType() reflect.Type

func (StateMachineLoggingConfigurationLevel) ToStateMachineLoggingConfigurationLevelOutput 

func (e StateMachineLoggingConfigurationLevel) ToStateMachineLoggingConfigurationLevelOutput() StateMachineLoggingConfigurationLevelOutput

func (StateMachineLoggingConfigurationLevel) ToStateMachineLoggingConfigurationLevelOutputWithContext 

func (e StateMachineLoggingConfigurationLevel) ToStateMachineLoggingConfigurationLevelOutputWithContext(ctx context.Context) StateMachineLoggingConfigurationLevelOutput

func (StateMachineLoggingConfigurationLevel) ToStateMachineLoggingConfigurationLevelPtrOutput 

func (e StateMachineLoggingConfigurationLevel) ToStateMachineLoggingConfigurationLevelPtrOutput() StateMachineLoggingConfigurationLevelPtrOutput

func (StateMachineLoggingConfigurationLevel) ToStateMachineLoggingConfigurationLevelPtrOutputWithContext 

func (e StateMachineLoggingConfigurationLevel) ToStateMachineLoggingConfigurationLevelPtrOutputWithContext(ctx context.Context) StateMachineLoggingConfigurationLevelPtrOutput

func (StateMachineLoggingConfigurationLevel) ToStringOutput 

func (e StateMachineLoggingConfigurationLevel) ToStringOutput() pulumi.StringOutput

func (StateMachineLoggingConfigurationLevel) ToStringOutputWithContext 

func (e StateMachineLoggingConfigurationLevel) ToStringOutputWithContext(ctx context.Context) pulumi.StringOutput

func (StateMachineLoggingConfigurationLevel) ToStringPtrOutput 

func (e StateMachineLoggingConfigurationLevel) ToStringPtrOutput() pulumi.StringPtrOutput

func (StateMachineLoggingConfigurationLevel) ToStringPtrOutputWithContext 

func (e StateMachineLoggingConfigurationLevel) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput

type StateMachineLoggingConfigurationLevelInput 

type StateMachineLoggingConfigurationLevelInput interface {
	pulumi.Input

	ToStateMachineLoggingConfigurationLevelOutput() StateMachineLoggingConfigurationLevelOutput
	ToStateMachineLoggingConfigurationLevelOutputWithContext(context.Context) StateMachineLoggingConfigurationLevelOutput
}

StateMachineLoggingConfigurationLevelInput is an input type that accepts StateMachineLoggingConfigurationLevelArgs and StateMachineLoggingConfigurationLevelOutput values. You can construct a concrete instance of `StateMachineLoggingConfigurationLevelInput` via: 

StateMachineLoggingConfigurationLevelArgs{...}

type StateMachineLoggingConfigurationLevelOutput 

type StateMachineLoggingConfigurationLevelOutput struct{ *pulumi.OutputState }

func (StateMachineLoggingConfigurationLevelOutput) ElementType 

func (StateMachineLoggingConfigurationLevelOutput) ElementType() reflect.Type

func (StateMachineLoggingConfigurationLevelOutput) ToStateMachineLoggingConfigurationLevelOutput 

func (o StateMachineLoggingConfigurationLevelOutput) ToStateMachineLoggingConfigurationLevelOutput() StateMachineLoggingConfigurationLevelOutput

func (StateMachineLoggingConfigurationLevelOutput) ToStateMachineLoggingConfigurationLevelOutputWithContext 

func (o StateMachineLoggingConfigurationLevelOutput) ToStateMachineLoggingConfigurationLevelOutputWithContext(ctx context.Context) StateMachineLoggingConfigurationLevelOutput

func (StateMachineLoggingConfigurationLevelOutput) ToStateMachineLoggingConfigurationLevelPtrOutput 

func (o StateMachineLoggingConfigurationLevelOutput) ToStateMachineLoggingConfigurationLevelPtrOutput() StateMachineLoggingConfigurationLevelPtrOutput

func (StateMachineLoggingConfigurationLevelOutput) ToStateMachineLoggingConfigurationLevelPtrOutputWithContext 

func (o StateMachineLoggingConfigurationLevelOutput) ToStateMachineLoggingConfigurationLevelPtrOutputWithContext(ctx context.Context) StateMachineLoggingConfigurationLevelPtrOutput

func (StateMachineLoggingConfigurationLevelOutput) ToStringOutput 

func (o StateMachineLoggingConfigurationLevelOutput) ToStringOutput() pulumi.StringOutput

func (StateMachineLoggingConfigurationLevelOutput) ToStringOutputWithContext 

func (o StateMachineLoggingConfigurationLevelOutput) ToStringOutputWithContext(ctx context.Context) pulumi.StringOutput

func (StateMachineLoggingConfigurationLevelOutput) ToStringPtrOutput 

func (o StateMachineLoggingConfigurationLevelOutput) ToStringPtrOutput() pulumi.StringPtrOutput

func (StateMachineLoggingConfigurationLevelOutput) ToStringPtrOutputWithContext 

func (o StateMachineLoggingConfigurationLevelOutput) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput

type StateMachineLoggingConfigurationLevelPtrInput 

type StateMachineLoggingConfigurationLevelPtrInput interface {
	pulumi.Input

	ToStateMachineLoggingConfigurationLevelPtrOutput() StateMachineLoggingConfigurationLevelPtrOutput
	ToStateMachineLoggingConfigurationLevelPtrOutputWithContext(context.Context) StateMachineLoggingConfigurationLevelPtrOutput
}

func StateMachineLoggingConfigurationLevelPtr 

func StateMachineLoggingConfigurationLevelPtr(v string) StateMachineLoggingConfigurationLevelPtrInput

type StateMachineLoggingConfigurationLevelPtrOutput 

type StateMachineLoggingConfigurationLevelPtrOutput struct{ *pulumi.OutputState }

func (StateMachineLoggingConfigurationLevelPtrOutput) Elem 

func (o StateMachineLoggingConfigurationLevelPtrOutput) Elem() StateMachineLoggingConfigurationLevelOutput

func (StateMachineLoggingConfigurationLevelPtrOutput) ElementType 

func (StateMachineLoggingConfigurationLevelPtrOutput) ElementType() reflect.Type

func (StateMachineLoggingConfigurationLevelPtrOutput) ToStateMachineLoggingConfigurationLevelPtrOutput 

func (o StateMachineLoggingConfigurationLevelPtrOutput) ToStateMachineLoggingConfigurationLevelPtrOutput() StateMachineLoggingConfigurationLevelPtrOutput

func (StateMachineLoggingConfigurationLevelPtrOutput) ToStateMachineLoggingConfigurationLevelPtrOutputWithContext 

func (o StateMachineLoggingConfigurationLevelPtrOutput) ToStateMachineLoggingConfigurationLevelPtrOutputWithContext(ctx context.Context) StateMachineLoggingConfigurationLevelPtrOutput

func (StateMachineLoggingConfigurationLevelPtrOutput) ToStringPtrOutput 

func (o StateMachineLoggingConfigurationLevelPtrOutput) ToStringPtrOutput() pulumi.StringPtrOutput

func (StateMachineLoggingConfigurationLevelPtrOutput) ToStringPtrOutputWithContext 

func (o StateMachineLoggingConfigurationLevelPtrOutput) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput

type StateMachineLoggingConfigurationOutput 

type StateMachineLoggingConfigurationOutput struct{ *pulumi.OutputState }

func (StateMachineLoggingConfigurationOutput) Destinations 

func (o StateMachineLoggingConfigurationOutput) Destinations() StateMachineLogDestinationArrayOutput

func (StateMachineLoggingConfigurationOutput) ElementType 

func (StateMachineLoggingConfigurationOutput) ElementType() reflect.Type

func (StateMachineLoggingConfigurationOutput) IncludeExecutionData 

func (o StateMachineLoggingConfigurationOutput) IncludeExecutionData() pulumi.BoolPtrOutput

func (StateMachineLoggingConfigurationOutput) Level 

func (o StateMachineLoggingConfigurationOutput) Level() StateMachineLoggingConfigurationLevelPtrOutput

func (StateMachineLoggingConfigurationOutput) ToStateMachineLoggingConfigurationOutput 

func (o StateMachineLoggingConfigurationOutput) ToStateMachineLoggingConfigurationOutput() StateMachineLoggingConfigurationOutput

func (StateMachineLoggingConfigurationOutput) ToStateMachineLoggingConfigurationOutputWithContext 

func (o StateMachineLoggingConfigurationOutput) ToStateMachineLoggingConfigurationOutputWithContext(ctx context.Context) StateMachineLoggingConfigurationOutput

func (StateMachineLoggingConfigurationOutput) ToStateMachineLoggingConfigurationPtrOutput 

func (o StateMachineLoggingConfigurationOutput) ToStateMachineLoggingConfigurationPtrOutput() StateMachineLoggingConfigurationPtrOutput

func (StateMachineLoggingConfigurationOutput) ToStateMachineLoggingConfigurationPtrOutputWithContext 

func (o StateMachineLoggingConfigurationOutput) ToStateMachineLoggingConfigurationPtrOutputWithContext(ctx context.Context) StateMachineLoggingConfigurationPtrOutput

type StateMachineLoggingConfigurationPtrInput 

type StateMachineLoggingConfigurationPtrInput interface {
	pulumi.Input

	ToStateMachineLoggingConfigurationPtrOutput() StateMachineLoggingConfigurationPtrOutput
	ToStateMachineLoggingConfigurationPtrOutputWithContext(context.Context) StateMachineLoggingConfigurationPtrOutput
}

StateMachineLoggingConfigurationPtrInput is an input type that accepts StateMachineLoggingConfigurationArgs, StateMachineLoggingConfigurationPtr and StateMachineLoggingConfigurationPtrOutput values. You can construct a concrete instance of `StateMachineLoggingConfigurationPtrInput` via: 

        StateMachineLoggingConfigurationArgs{...}

or:

        nil

func StateMachineLoggingConfigurationPtr 

func StateMachineLoggingConfigurationPtr(v *StateMachineLoggingConfigurationArgs) StateMachineLoggingConfigurationPtrInput

type StateMachineLoggingConfigurationPtrOutput 

type StateMachineLoggingConfigurationPtrOutput struct{ *pulumi.OutputState }

func (StateMachineLoggingConfigurationPtrOutput) Destinations 

func (o StateMachineLoggingConfigurationPtrOutput) Destinations() StateMachineLogDestinationArrayOutput

func (StateMachineLoggingConfigurationPtrOutput) Elem 

func (o StateMachineLoggingConfigurationPtrOutput) Elem() StateMachineLoggingConfigurationOutput

func (StateMachineLoggingConfigurationPtrOutput) ElementType 

func (StateMachineLoggingConfigurationPtrOutput) ElementType() reflect.Type

func (StateMachineLoggingConfigurationPtrOutput) IncludeExecutionData 

func (o StateMachineLoggingConfigurationPtrOutput) IncludeExecutionData() pulumi.BoolPtrOutput

func (StateMachineLoggingConfigurationPtrOutput) Level 

func (o StateMachineLoggingConfigurationPtrOutput) Level() StateMachineLoggingConfigurationLevelPtrOutput

func (StateMachineLoggingConfigurationPtrOutput) ToStateMachineLoggingConfigurationPtrOutput 

func (o StateMachineLoggingConfigurationPtrOutput) ToStateMachineLoggingConfigurationPtrOutput() StateMachineLoggingConfigurationPtrOutput

func (StateMachineLoggingConfigurationPtrOutput) ToStateMachineLoggingConfigurationPtrOutputWithContext 

func (o StateMachineLoggingConfigurationPtrOutput) ToStateMachineLoggingConfigurationPtrOutputWithContext(ctx context.Context) StateMachineLoggingConfigurationPtrOutput

type StateMachineOutput 

type StateMachineOutput struct{ *pulumi.OutputState }

func (StateMachineOutput) Arn added in v0.17.0 

func (o StateMachineOutput) Arn() pulumi.StringOutput

func (StateMachineOutput) Definition added in v0.17.0 

func (o StateMachineOutput) Definition() StateMachineDefinitionPtrOutput

func (StateMachineOutput) DefinitionS3Location added in v0.17.0 

func (o StateMachineOutput) DefinitionS3Location() StateMachineS3LocationPtrOutput

func (StateMachineOutput) DefinitionString added in v0.17.0 

func (o StateMachineOutput) DefinitionString() pulumi.StringPtrOutput

func (StateMachineOutput) DefinitionSubstitutions added in v0.17.0 

func (o StateMachineOutput) DefinitionSubstitutions() StateMachineDefinitionSubstitutionsPtrOutput

func (StateMachineOutput) ElementType 

func (StateMachineOutput) ElementType() reflect.Type

func (StateMachineOutput) LoggingConfiguration added in v0.17.0 

func (o StateMachineOutput) LoggingConfiguration() StateMachineLoggingConfigurationPtrOutput

func (StateMachineOutput) Name added in v0.17.0 

func (o StateMachineOutput) Name() pulumi.StringOutput

func (StateMachineOutput) RoleArn added in v0.17.0 

func (o StateMachineOutput) RoleArn() pulumi.StringOutput

func (StateMachineOutput) StateMachineName added in v0.17.0 

func (o StateMachineOutput) StateMachineName() pulumi.StringPtrOutput

func (StateMachineOutput) StateMachineRevisionId added in v0.54.0 

func (o StateMachineOutput) StateMachineRevisionId() pulumi.StringOutput

func (StateMachineOutput) StateMachineType added in v0.17.0 

func (o StateMachineOutput) StateMachineType() StateMachineTypePtrOutput

func (StateMachineOutput) Tags added in v0.17.0 

func (o StateMachineOutput) Tags() StateMachineTagsEntryArrayOutput

func (StateMachineOutput) ToStateMachineOutput 

func (o StateMachineOutput) ToStateMachineOutput() StateMachineOutput

func (StateMachineOutput) ToStateMachineOutputWithContext 

func (o StateMachineOutput) ToStateMachineOutputWithContext(ctx context.Context) StateMachineOutput

func (StateMachineOutput) TracingConfiguration added in v0.17.0 

func (o StateMachineOutput) TracingConfiguration() StateMachineTracingConfigurationPtrOutput

type StateMachineS3Location 

type StateMachineS3Location struct {
	Bucket  string  `pulumi:"bucket"`
	Key     string  `pulumi:"key"`
	Version *string `pulumi:"version"`
}

type StateMachineS3LocationArgs 

type StateMachineS3LocationArgs struct {
	Bucket  pulumi.StringInput    `pulumi:"bucket"`
	Key     pulumi.StringInput    `pulumi:"key"`
	Version pulumi.StringPtrInput `pulumi:"version"`
}

func (StateMachineS3LocationArgs) ElementType 

func (StateMachineS3LocationArgs) ElementType() reflect.Type

func (StateMachineS3LocationArgs) ToStateMachineS3LocationOutput 

func (i StateMachineS3LocationArgs) ToStateMachineS3LocationOutput() StateMachineS3LocationOutput

func (StateMachineS3LocationArgs) ToStateMachineS3LocationOutputWithContext 

func (i StateMachineS3LocationArgs) ToStateMachineS3LocationOutputWithContext(ctx context.Context) StateMachineS3LocationOutput

func (StateMachineS3LocationArgs) ToStateMachineS3LocationPtrOutput 

func (i StateMachineS3LocationArgs) ToStateMachineS3LocationPtrOutput() StateMachineS3LocationPtrOutput

func (StateMachineS3LocationArgs) ToStateMachineS3LocationPtrOutputWithContext 

func (i StateMachineS3LocationArgs) ToStateMachineS3LocationPtrOutputWithContext(ctx context.Context) StateMachineS3LocationPtrOutput

type StateMachineS3LocationInput 

type StateMachineS3LocationInput interface {
	pulumi.Input

	ToStateMachineS3LocationOutput() StateMachineS3LocationOutput
	ToStateMachineS3LocationOutputWithContext(context.Context) StateMachineS3LocationOutput
}

StateMachineS3LocationInput is an input type that accepts StateMachineS3LocationArgs and StateMachineS3LocationOutput values. You can construct a concrete instance of `StateMachineS3LocationInput` via: 

StateMachineS3LocationArgs{...}

type StateMachineS3LocationOutput 

type StateMachineS3LocationOutput struct{ *pulumi.OutputState }

func (StateMachineS3LocationOutput) Bucket 

func (o StateMachineS3LocationOutput) Bucket() pulumi.StringOutput

func (StateMachineS3LocationOutput) ElementType 

func (StateMachineS3LocationOutput) ElementType() reflect.Type

func (StateMachineS3LocationOutput) Key 

func (o StateMachineS3LocationOutput) Key() pulumi.StringOutput

func (StateMachineS3LocationOutput) ToStateMachineS3LocationOutput 

func (o StateMachineS3LocationOutput) ToStateMachineS3LocationOutput() StateMachineS3LocationOutput

func (StateMachineS3LocationOutput) ToStateMachineS3LocationOutputWithContext 

func (o StateMachineS3LocationOutput) ToStateMachineS3LocationOutputWithContext(ctx context.Context) StateMachineS3LocationOutput

func (StateMachineS3LocationOutput) ToStateMachineS3LocationPtrOutput 

func (o StateMachineS3LocationOutput) ToStateMachineS3LocationPtrOutput() StateMachineS3LocationPtrOutput

func (StateMachineS3LocationOutput) ToStateMachineS3LocationPtrOutputWithContext 

func (o StateMachineS3LocationOutput) ToStateMachineS3LocationPtrOutputWithContext(ctx context.Context) StateMachineS3LocationPtrOutput

func (StateMachineS3LocationOutput) Version 

func (o StateMachineS3LocationOutput) Version() pulumi.StringPtrOutput

type StateMachineS3LocationPtrInput 

type StateMachineS3LocationPtrInput interface {
	pulumi.Input

	ToStateMachineS3LocationPtrOutput() StateMachineS3LocationPtrOutput
	ToStateMachineS3LocationPtrOutputWithContext(context.Context) StateMachineS3LocationPtrOutput
}

StateMachineS3LocationPtrInput is an input type that accepts StateMachineS3LocationArgs, StateMachineS3LocationPtr and StateMachineS3LocationPtrOutput values. You can construct a concrete instance of `StateMachineS3LocationPtrInput` via: 

        StateMachineS3LocationArgs{...}

or:

        nil

func StateMachineS3LocationPtr 

func StateMachineS3LocationPtr(v *StateMachineS3LocationArgs) StateMachineS3LocationPtrInput

type StateMachineS3LocationPtrOutput 

type StateMachineS3LocationPtrOutput struct{ *pulumi.OutputState }

func (StateMachineS3LocationPtrOutput) Bucket 

func (o StateMachineS3LocationPtrOutput) Bucket() pulumi.StringPtrOutput

func (StateMachineS3LocationPtrOutput) Elem 

func (o StateMachineS3LocationPtrOutput) Elem() StateMachineS3LocationOutput

func (StateMachineS3LocationPtrOutput) ElementType 

func (StateMachineS3LocationPtrOutput) ElementType() reflect.Type

func (StateMachineS3LocationPtrOutput) Key 

func (o StateMachineS3LocationPtrOutput) Key() pulumi.StringPtrOutput

func (StateMachineS3LocationPtrOutput) ToStateMachineS3LocationPtrOutput 

func (o StateMachineS3LocationPtrOutput) ToStateMachineS3LocationPtrOutput() StateMachineS3LocationPtrOutput

func (StateMachineS3LocationPtrOutput) ToStateMachineS3LocationPtrOutputWithContext 

func (o StateMachineS3LocationPtrOutput) ToStateMachineS3LocationPtrOutputWithContext(ctx context.Context) StateMachineS3LocationPtrOutput

func (StateMachineS3LocationPtrOutput) Version 

func (o StateMachineS3LocationPtrOutput) Version() pulumi.StringPtrOutput

type StateMachineState 

type StateMachineState struct {
}

func (StateMachineState) ElementType 

func (StateMachineState) ElementType() reflect.Type

type StateMachineTagsEntry 

type StateMachineTagsEntry struct {
	Key   string `pulumi:"key"`
	Value string `pulumi:"value"`
}

type StateMachineTagsEntryArgs 

type StateMachineTagsEntryArgs struct {
	Key   pulumi.StringInput `pulumi:"key"`
	Value pulumi.StringInput `pulumi:"value"`
}

func (StateMachineTagsEntryArgs) ElementType 

func (StateMachineTagsEntryArgs) ElementType() reflect.Type

func (StateMachineTagsEntryArgs) ToStateMachineTagsEntryOutput 

func (i StateMachineTagsEntryArgs) ToStateMachineTagsEntryOutput() StateMachineTagsEntryOutput

func (StateMachineTagsEntryArgs) ToStateMachineTagsEntryOutputWithContext 

func (i StateMachineTagsEntryArgs) ToStateMachineTagsEntryOutputWithContext(ctx context.Context) StateMachineTagsEntryOutput

type StateMachineTagsEntryArray 

type StateMachineTagsEntryArray []StateMachineTagsEntryInput

func (StateMachineTagsEntryArray) ElementType 

func (StateMachineTagsEntryArray) ElementType() reflect.Type

func (StateMachineTagsEntryArray) ToStateMachineTagsEntryArrayOutput 

func (i StateMachineTagsEntryArray) ToStateMachineTagsEntryArrayOutput() StateMachineTagsEntryArrayOutput

func (StateMachineTagsEntryArray) ToStateMachineTagsEntryArrayOutputWithContext 

func (i StateMachineTagsEntryArray) ToStateMachineTagsEntryArrayOutputWithContext(ctx context.Context) StateMachineTagsEntryArrayOutput

type StateMachineTagsEntryArrayInput 

type StateMachineTagsEntryArrayInput interface {
	pulumi.Input

	ToStateMachineTagsEntryArrayOutput() StateMachineTagsEntryArrayOutput
	ToStateMachineTagsEntryArrayOutputWithContext(context.Context) StateMachineTagsEntryArrayOutput
}

StateMachineTagsEntryArrayInput is an input type that accepts StateMachineTagsEntryArray and StateMachineTagsEntryArrayOutput values. You can construct a concrete instance of `StateMachineTagsEntryArrayInput` via: 

StateMachineTagsEntryArray{ StateMachineTagsEntryArgs{...} }

type StateMachineTagsEntryArrayOutput 

type StateMachineTagsEntryArrayOutput struct{ *pulumi.OutputState }

func (StateMachineTagsEntryArrayOutput) ElementType 

func (StateMachineTagsEntryArrayOutput) ElementType() reflect.Type

func (StateMachineTagsEntryArrayOutput) Index 

func (o StateMachineTagsEntryArrayOutput) Index(i pulumi.IntInput) StateMachineTagsEntryOutput

func (StateMachineTagsEntryArrayOutput) ToStateMachineTagsEntryArrayOutput 

func (o StateMachineTagsEntryArrayOutput) ToStateMachineTagsEntryArrayOutput() StateMachineTagsEntryArrayOutput

func (StateMachineTagsEntryArrayOutput) ToStateMachineTagsEntryArrayOutputWithContext 

func (o StateMachineTagsEntryArrayOutput) ToStateMachineTagsEntryArrayOutputWithContext(ctx context.Context) StateMachineTagsEntryArrayOutput

type StateMachineTagsEntryInput 

type StateMachineTagsEntryInput interface {
	pulumi.Input

	ToStateMachineTagsEntryOutput() StateMachineTagsEntryOutput
	ToStateMachineTagsEntryOutputWithContext(context.Context) StateMachineTagsEntryOutput
}

StateMachineTagsEntryInput is an input type that accepts StateMachineTagsEntryArgs and StateMachineTagsEntryOutput values. You can construct a concrete instance of `StateMachineTagsEntryInput` via: 

StateMachineTagsEntryArgs{...}

type StateMachineTagsEntryOutput 

type StateMachineTagsEntryOutput struct{ *pulumi.OutputState }

func (StateMachineTagsEntryOutput) ElementType 

func (StateMachineTagsEntryOutput) ElementType() reflect.Type

func (StateMachineTagsEntryOutput) Key 

func (o StateMachineTagsEntryOutput) Key() pulumi.StringOutput

func (StateMachineTagsEntryOutput) ToStateMachineTagsEntryOutput 

func (o StateMachineTagsEntryOutput) ToStateMachineTagsEntryOutput() StateMachineTagsEntryOutput

func (StateMachineTagsEntryOutput) ToStateMachineTagsEntryOutputWithContext 

func (o StateMachineTagsEntryOutput) ToStateMachineTagsEntryOutputWithContext(ctx context.Context) StateMachineTagsEntryOutput

func (StateMachineTagsEntryOutput) Value 

func (o StateMachineTagsEntryOutput) Value() pulumi.StringOutput

type StateMachineTracingConfiguration 

type StateMachineTracingConfiguration struct {
	Enabled *bool `pulumi:"enabled"`
}

type StateMachineTracingConfigurationArgs 

type StateMachineTracingConfigurationArgs struct {
	Enabled pulumi.BoolPtrInput `pulumi:"enabled"`
}

func (StateMachineTracingConfigurationArgs) ElementType 

func (StateMachineTracingConfigurationArgs) ElementType() reflect.Type

func (StateMachineTracingConfigurationArgs) ToStateMachineTracingConfigurationOutput 

func (i StateMachineTracingConfigurationArgs) ToStateMachineTracingConfigurationOutput() StateMachineTracingConfigurationOutput

func (StateMachineTracingConfigurationArgs) ToStateMachineTracingConfigurationOutputWithContext 

func (i StateMachineTracingConfigurationArgs) ToStateMachineTracingConfigurationOutputWithContext(ctx context.Context) StateMachineTracingConfigurationOutput

func (StateMachineTracingConfigurationArgs) ToStateMachineTracingConfigurationPtrOutput 

func (i StateMachineTracingConfigurationArgs) ToStateMachineTracingConfigurationPtrOutput() StateMachineTracingConfigurationPtrOutput

func (StateMachineTracingConfigurationArgs) ToStateMachineTracingConfigurationPtrOutputWithContext 

func (i StateMachineTracingConfigurationArgs) ToStateMachineTracingConfigurationPtrOutputWithContext(ctx context.Context) StateMachineTracingConfigurationPtrOutput

type StateMachineTracingConfigurationInput 

type StateMachineTracingConfigurationInput interface {
	pulumi.Input

	ToStateMachineTracingConfigurationOutput() StateMachineTracingConfigurationOutput
	ToStateMachineTracingConfigurationOutputWithContext(context.Context) StateMachineTracingConfigurationOutput
}

StateMachineTracingConfigurationInput is an input type that accepts StateMachineTracingConfigurationArgs and StateMachineTracingConfigurationOutput values. You can construct a concrete instance of `StateMachineTracingConfigurationInput` via: 

StateMachineTracingConfigurationArgs{...}

type StateMachineTracingConfigurationOutput 

type StateMachineTracingConfigurationOutput struct{ *pulumi.OutputState }

func (StateMachineTracingConfigurationOutput) ElementType 

func (StateMachineTracingConfigurationOutput) ElementType() reflect.Type

func (StateMachineTracingConfigurationOutput) Enabled 

func (o StateMachineTracingConfigurationOutput) Enabled() pulumi.BoolPtrOutput

func (StateMachineTracingConfigurationOutput) ToStateMachineTracingConfigurationOutput 

func (o StateMachineTracingConfigurationOutput) ToStateMachineTracingConfigurationOutput() StateMachineTracingConfigurationOutput

func (StateMachineTracingConfigurationOutput) ToStateMachineTracingConfigurationOutputWithContext 

func (o StateMachineTracingConfigurationOutput) ToStateMachineTracingConfigurationOutputWithContext(ctx context.Context) StateMachineTracingConfigurationOutput

func (StateMachineTracingConfigurationOutput) ToStateMachineTracingConfigurationPtrOutput 

func (o StateMachineTracingConfigurationOutput) ToStateMachineTracingConfigurationPtrOutput() StateMachineTracingConfigurationPtrOutput

func (StateMachineTracingConfigurationOutput) ToStateMachineTracingConfigurationPtrOutputWithContext 

func (o StateMachineTracingConfigurationOutput) ToStateMachineTracingConfigurationPtrOutputWithContext(ctx context.Context) StateMachineTracingConfigurationPtrOutput

type StateMachineTracingConfigurationPtrInput 

type StateMachineTracingConfigurationPtrInput interface {
	pulumi.Input

	ToStateMachineTracingConfigurationPtrOutput() StateMachineTracingConfigurationPtrOutput
	ToStateMachineTracingConfigurationPtrOutputWithContext(context.Context) StateMachineTracingConfigurationPtrOutput
}

StateMachineTracingConfigurationPtrInput is an input type that accepts StateMachineTracingConfigurationArgs, StateMachineTracingConfigurationPtr and StateMachineTracingConfigurationPtrOutput values. You can construct a concrete instance of `StateMachineTracingConfigurationPtrInput` via: 

        StateMachineTracingConfigurationArgs{...}

or:

        nil

func StateMachineTracingConfigurationPtr 

func StateMachineTracingConfigurationPtr(v *StateMachineTracingConfigurationArgs) StateMachineTracingConfigurationPtrInput

type StateMachineTracingConfigurationPtrOutput 

type StateMachineTracingConfigurationPtrOutput struct{ *pulumi.OutputState }

func (StateMachineTracingConfigurationPtrOutput) Elem 

func (o StateMachineTracingConfigurationPtrOutput) Elem() StateMachineTracingConfigurationOutput

func (StateMachineTracingConfigurationPtrOutput) ElementType 

func (StateMachineTracingConfigurationPtrOutput) ElementType() reflect.Type

func (StateMachineTracingConfigurationPtrOutput) Enabled 

func (o StateMachineTracingConfigurationPtrOutput) Enabled() pulumi.BoolPtrOutput

func (StateMachineTracingConfigurationPtrOutput) ToStateMachineTracingConfigurationPtrOutput 

func (o StateMachineTracingConfigurationPtrOutput) ToStateMachineTracingConfigurationPtrOutput() StateMachineTracingConfigurationPtrOutput

func (StateMachineTracingConfigurationPtrOutput) ToStateMachineTracingConfigurationPtrOutputWithContext 

func (o StateMachineTracingConfigurationPtrOutput) ToStateMachineTracingConfigurationPtrOutputWithContext(ctx context.Context) StateMachineTracingConfigurationPtrOutput

type StateMachineType added in v0.2.0 

type StateMachineType string

func (StateMachineType) ElementType added in v0.2.0 

func (StateMachineType) ElementType() reflect.Type

func (StateMachineType) ToStateMachineTypeOutput added in v0.2.0 

func (e StateMachineType) ToStateMachineTypeOutput() StateMachineTypeOutput

func (StateMachineType) ToStateMachineTypeOutputWithContext added in v0.2.0 

func (e StateMachineType) ToStateMachineTypeOutputWithContext(ctx context.Context) StateMachineTypeOutput

func (StateMachineType) ToStateMachineTypePtrOutput added in v0.2.0 

func (e StateMachineType) ToStateMachineTypePtrOutput() StateMachineTypePtrOutput

func (StateMachineType) ToStateMachineTypePtrOutputWithContext added in v0.2.0 

func (e StateMachineType) ToStateMachineTypePtrOutputWithContext(ctx context.Context) StateMachineTypePtrOutput

func (StateMachineType) ToStringOutput added in v0.2.0 

func (e StateMachineType) ToStringOutput() pulumi.StringOutput

func (StateMachineType) ToStringOutputWithContext added in v0.2.0 

func (e StateMachineType) ToStringOutputWithContext(ctx context.Context) pulumi.StringOutput

func (StateMachineType) ToStringPtrOutput added in v0.2.0 

func (e StateMachineType) ToStringPtrOutput() pulumi.StringPtrOutput

func (StateMachineType) ToStringPtrOutputWithContext added in v0.2.0 

func (e StateMachineType) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput

type StateMachineTypeInput added in v0.2.0 

type StateMachineTypeInput interface {
	pulumi.Input

	ToStateMachineTypeOutput() StateMachineTypeOutput
	ToStateMachineTypeOutputWithContext(context.Context) StateMachineTypeOutput
}

StateMachineTypeInput is an input type that accepts StateMachineTypeArgs and StateMachineTypeOutput values. You can construct a concrete instance of `StateMachineTypeInput` via: 

StateMachineTypeArgs{...}

type StateMachineTypeOutput added in v0.2.0 

type StateMachineTypeOutput struct{ *pulumi.OutputState }

func (StateMachineTypeOutput) ElementType added in v0.2.0 

func (StateMachineTypeOutput) ElementType() reflect.Type

func (StateMachineTypeOutput) ToStateMachineTypeOutput added in v0.2.0 

func (o StateMachineTypeOutput) ToStateMachineTypeOutput() StateMachineTypeOutput

func (StateMachineTypeOutput) ToStateMachineTypeOutputWithContext added in v0.2.0 

func (o StateMachineTypeOutput) ToStateMachineTypeOutputWithContext(ctx context.Context) StateMachineTypeOutput

func (StateMachineTypeOutput) ToStateMachineTypePtrOutput added in v0.2.0 

func (o StateMachineTypeOutput) ToStateMachineTypePtrOutput() StateMachineTypePtrOutput

func (StateMachineTypeOutput) ToStateMachineTypePtrOutputWithContext added in v0.2.0 

func (o StateMachineTypeOutput) ToStateMachineTypePtrOutputWithContext(ctx context.Context) StateMachineTypePtrOutput

func (StateMachineTypeOutput) ToStringOutput added in v0.2.0 

func (o StateMachineTypeOutput) ToStringOutput() pulumi.StringOutput

func (StateMachineTypeOutput) ToStringOutputWithContext added in v0.2.0 

func (o StateMachineTypeOutput) ToStringOutputWithContext(ctx context.Context) pulumi.StringOutput

func (StateMachineTypeOutput) ToStringPtrOutput added in v0.2.0 

func (o StateMachineTypeOutput) ToStringPtrOutput() pulumi.StringPtrOutput

func (StateMachineTypeOutput) ToStringPtrOutputWithContext added in v0.2.0 

func (o StateMachineTypeOutput) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput

type StateMachineTypePtrInput added in v0.2.0 

type StateMachineTypePtrInput interface {
	pulumi.Input

	ToStateMachineTypePtrOutput() StateMachineTypePtrOutput
	ToStateMachineTypePtrOutputWithContext(context.Context) StateMachineTypePtrOutput
}

func StateMachineTypePtr added in v0.2.0 

func StateMachineTypePtr(v string) StateMachineTypePtrInput

type StateMachineTypePtrOutput added in v0.2.0 

type StateMachineTypePtrOutput struct{ *pulumi.OutputState }

func (StateMachineTypePtrOutput) Elem added in v0.2.0 

func (o StateMachineTypePtrOutput) Elem() StateMachineTypeOutput

func (StateMachineTypePtrOutput) ElementType added in v0.2.0 

func (StateMachineTypePtrOutput) ElementType() reflect.Type

func (StateMachineTypePtrOutput) ToStateMachineTypePtrOutput added in v0.2.0 

func (o StateMachineTypePtrOutput) ToStateMachineTypePtrOutput() StateMachineTypePtrOutput

func (StateMachineTypePtrOutput) ToStateMachineTypePtrOutputWithContext added in v0.2.0 

func (o StateMachineTypePtrOutput) ToStateMachineTypePtrOutputWithContext(ctx context.Context) StateMachineTypePtrOutput

func (StateMachineTypePtrOutput) ToStringPtrOutput added in v0.2.0 

func (o StateMachineTypePtrOutput) ToStringPtrOutput() pulumi.StringPtrOutput

func (StateMachineTypePtrOutput) ToStringPtrOutputWithContext added in v0.2.0 

func (o StateMachineTypePtrOutput) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.