types

package
v1.0.0-preview.121 Latest Latest
Warning

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

 Go to latest Published: Aug 14, 2026 License: Apache-2.0 Imports: 4 Imported by: 0

Documentation

Index

Examples

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type AccessDeniedException 

type AccessDeniedException struct {
	Message *string

	ErrorCodeOverride *string
	// contains filtered or unexported fields
}

You do not have sufficient access to perform this action.

func (*AccessDeniedException) Error 

func (e *AccessDeniedException) Error() string

func (*AccessDeniedException) ErrorCode 

func (e *AccessDeniedException) ErrorCode() string

func (*AccessDeniedException) ErrorFault 

func (e *AccessDeniedException) ErrorFault() smithy.ErrorFault

func (*AccessDeniedException) ErrorMessage 

func (e *AccessDeniedException) ErrorMessage() string

type AdvancedOptions 

type AdvancedOptions struct {

	// A structure that contains X12-specific advanced options, such as split options
	// for processing X12 EDI files.
	X12 *X12AdvancedOptions
	// contains filtered or unexported fields
}

A structure that contains advanced options for EDI processing. Currently, only X12 advanced options are supported.

type CapabilityConfiguration 

type CapabilityConfiguration interface {
	// contains filtered or unexported methods
}

A capability object. Currently, only EDI (electronic data interchange) capabilities are supported. A trading capability contains the information required to transform incoming EDI documents into JSON or XML outputs.

The following types satisfy this interface: 

CapabilityConfigurationMemberEdi
Example (OutputUsage) 
package main

import (
	"fmt"
	"github.com/aws/aws-sdk-go-v2/service/b2bi/types"
)

func main() {
	var union types.CapabilityConfiguration
	// type switches can be used to check the union value
	switch v := union.(type) {
	case *types.CapabilityConfigurationMemberEdi:
		_ = v.Value // Value is types.EdiConfiguration

	case *types.UnknownUnionMember:
		fmt.Println("unknown tag:", v.Tag)

	default:
		fmt.Println("union is nil or unknown type")

	}
}

type CapabilityConfigurationMemberEdi 

type CapabilityConfigurationMemberEdi struct {
	Value EdiConfiguration
	// contains filtered or unexported fields
}

An EDI (electronic data interchange) configuration object.

type CapabilityDirection 

type CapabilityDirection string
const (
	CapabilityDirectionInbound  CapabilityDirection = "INBOUND"
	CapabilityDirectionOutbound CapabilityDirection = "OUTBOUND"
)

Enum values for CapabilityDirection

func (CapabilityDirection) Values 

func (CapabilityDirection) Values() []CapabilityDirection

Values returns all known values for CapabilityDirection. Note that this can be expanded in the future, and so it is only as up to date as the client.

The ordering of this slice is not guaranteed to be stable across updates.

type CapabilityOptions 

type CapabilityOptions struct {

	// A structure that contains the inbound EDI options for the capability.
	InboundEdi *InboundEdiOptions

	// A structure that contains the outbound EDI options.
	OutboundEdi OutboundEdiOptions
	// contains filtered or unexported fields
}

Contains the details for an Outbound EDI capability.

type CapabilitySummary 

type CapabilitySummary struct {

	// Returns a system-assigned unique identifier for the capability.
	//
	// This member is required.
	CapabilityId *string

	// Returns a timestamp for creation date and time of the capability.
	//
	// This member is required.
	CreatedAt *time.Time

	// The display name of the capability.
	//
	// This member is required.
	Name *string

	// Returns the type of the capability. Currently, only edi is supported.
	//
	// This member is required.
	Type CapabilityType

	// Returns a timestamp that identifies the most recent date and time that the
	// capability was modified.
	ModifiedAt *time.Time
	// contains filtered or unexported fields
}

Returns the capability summary details. A trading capability contains the information required to transform incoming EDI documents into JSON or XML outputs.

type CapabilityType 

type CapabilityType string
const (
	CapabilityTypeEdi CapabilityType = "edi"
)

Enum values for CapabilityType

func (CapabilityType) Values 

func (CapabilityType) Values() []CapabilityType

Values returns all known values for CapabilityType. Note that this can be expanded in the future, and so it is only as up to date as the client.

The ordering of this slice is not guaranteed to be stable across updates.

type ConflictException 

type ConflictException struct {
	Message *string

	ErrorCodeOverride *string
	// contains filtered or unexported fields
}

A conflict exception is thrown when you attempt to delete a resource (such as a profile or a capability) that is being used by other resources.

func (*ConflictException) Error 

func (e *ConflictException) Error() string

func (*ConflictException) ErrorCode 

func (e *ConflictException) ErrorCode() string

func (*ConflictException) ErrorFault 

func (e *ConflictException) ErrorFault() smithy.ErrorFault

func (*ConflictException) ErrorMessage 

func (e *ConflictException) ErrorMessage() string

type ConversionSource 

type ConversionSource struct {

	// The format for the input file: either JSON or XML.
	//
	// This member is required.
	FileFormat ConversionSourceFormat

	// File to be converted
	//
	// This member is required.
	InputFile InputFileSource
	// contains filtered or unexported fields
}

Describes the input for an outbound transformation.

type ConversionSourceFormat 

type ConversionSourceFormat string
const (
	ConversionSourceFormatJson ConversionSourceFormat = "JSON"
	ConversionSourceFormatXml  ConversionSourceFormat = "XML"
)

Enum values for ConversionSourceFormat

func (ConversionSourceFormat) Values 

func (ConversionSourceFormat) Values() []ConversionSourceFormat

Values returns all known values for ConversionSourceFormat. Note that this can be expanded in the future, and so it is only as up to date as the client.

The ordering of this slice is not guaranteed to be stable across updates.

type ConversionTarget 

type ConversionTarget struct {

	// Currently, only X12 format is supported.
	//
	// This member is required.
	FileFormat ConversionTargetFormat

	// A structure that contains advanced options for EDI processing. Currently, only
	// X12 advanced options are supported.
	AdvancedOptions *AdvancedOptions

	// A structure that contains the formatting details for the conversion target.
	FormatDetails ConversionTargetFormatDetails

	// Customer uses this to provide a sample on what should file look like after
	// conversion X12 EDI use case around this would be discovering the file syntax
	OutputSampleFile OutputSampleFileSource
	// contains filtered or unexported fields
}

Provide a sample of what the output of the transformation should look like.

type ConversionTargetFormat 

type ConversionTargetFormat string
const (
	ConversionTargetFormatX12 ConversionTargetFormat = "X12"
)

Enum values for ConversionTargetFormat

func (ConversionTargetFormat) Values 

func (ConversionTargetFormat) Values() []ConversionTargetFormat

Values returns all known values for ConversionTargetFormat. Note that this can be expanded in the future, and so it is only as up to date as the client.

The ordering of this slice is not guaranteed to be stable across updates.

type ConversionTargetFormatDetails 

type ConversionTargetFormatDetails interface {
	// contains filtered or unexported methods
}

Contains a structure describing the X12 details for the conversion target.

The following types satisfy this interface: 

ConversionTargetFormatDetailsMemberX12
Example (OutputUsage) 
package main

import (
	"fmt"
	"github.com/aws/aws-sdk-go-v2/service/b2bi/types"
)

func main() {
	var union types.ConversionTargetFormatDetails
	// type switches can be used to check the union value
	switch v := union.(type) {
	case *types.ConversionTargetFormatDetailsMemberX12:
		_ = v.Value // Value is types.X12Details

	case *types.UnknownUnionMember:
		fmt.Println("unknown tag:", v.Tag)

	default:
		fmt.Println("union is nil or unknown type")

	}
}

type ConversionTargetFormatDetailsMemberX12 

type ConversionTargetFormatDetailsMemberX12 struct {
	Value X12Details
	// contains filtered or unexported fields
}

A structure that contains the X12 transaction set and version. The X12 structure is used when the system transforms an EDI (electronic data interchange) file.

If an EDI input file contains more than one transaction, each transaction must have the same transaction set and version, for example 214/4010. If not, the transformer cannot parse the file.

type EdiConfiguration 

type EdiConfiguration struct {

	// Contains the Amazon S3 bucket and prefix for the location of the input file,
	// which is contained in an S3Location object.
	//
	// This member is required.
	InputLocation *S3Location

	// Contains the Amazon S3 bucket and prefix for the location of the output file,
	// which is contained in an S3Location object.
	//
	// This member is required.
	OutputLocation *S3Location

	// Returns the system-assigned unique identifier for the transformer.
	//
	// This member is required.
	TransformerId *string

	// Returns the type of the capability. Currently, only edi is supported.
	//
	// This member is required.
	Type EdiType

	// Specifies whether this is capability is for inbound or outbound transformations.
	CapabilityDirection CapabilityDirection
	// contains filtered or unexported fields
}

Specifies the details for the EDI (electronic data interchange) transformation.

type EdiType 

type EdiType interface {
	// contains filtered or unexported methods
}

Specifies the details for the EDI standard that is being used for the transformer. Currently, only X12 is supported. X12 is a set of standards and corresponding messages that define specific business documents.

The following types satisfy this interface: 

EdiTypeMemberX12Details
Example (OutputUsage) 
package main

import (
	"fmt"
	"github.com/aws/aws-sdk-go-v2/service/b2bi/types"
)

func main() {
	var union types.EdiType
	// type switches can be used to check the union value
	switch v := union.(type) {
	case *types.EdiTypeMemberX12Details:
		_ = v.Value // Value is types.X12Details

	case *types.UnknownUnionMember:
		fmt.Println("unknown tag:", v.Tag)

	default:
		fmt.Println("union is nil or unknown type")

	}
}

type EdiTypeMemberX12Details 

type EdiTypeMemberX12Details struct {
	Value X12Details
	// contains filtered or unexported fields
}

Returns the details for the EDI standard that is being used for the transformer. Currently, only X12 is supported. X12 is a set of standards and corresponding messages that define specific business documents.

type ElementRequirement 

type ElementRequirement string
const (
	ElementRequirementOptional  ElementRequirement = "OPTIONAL"
	ElementRequirementMandatory ElementRequirement = "MANDATORY"
)

Enum values for ElementRequirement

func (ElementRequirement) Values 

func (ElementRequirement) Values() []ElementRequirement

Values returns all known values for ElementRequirement. Note that this can be expanded in the future, and so it is only as up to date as the client.

The ordering of this slice is not guaranteed to be stable across updates.

type FileFormat 

type FileFormat string
const (
	FileFormatXml     FileFormat = "XML"
	FileFormatJson    FileFormat = "JSON"
	FileFormatNotUsed FileFormat = "NOT_USED"
)

Enum values for FileFormat

func (FileFormat) Values 

func (FileFormat) Values() []FileFormat

Values returns all known values for FileFormat. Note that this can be expanded in the future, and so it is only as up to date as the client.

The ordering of this slice is not guaranteed to be stable across updates.

type FormatOptions 

type FormatOptions interface {
	// contains filtered or unexported methods
}

A structure that contains the X12 transaction set and version.

The following types satisfy this interface: 

FormatOptionsMemberX12
Example (OutputUsage) 
package main

import (
	"fmt"
	"github.com/aws/aws-sdk-go-v2/service/b2bi/types"
)

func main() {
	var union types.FormatOptions
	// type switches can be used to check the union value
	switch v := union.(type) {
	case *types.FormatOptionsMemberX12:
		_ = v.Value // Value is types.X12Details

	case *types.UnknownUnionMember:
		fmt.Println("unknown tag:", v.Tag)

	default:
		fmt.Println("union is nil or unknown type")

	}
}

type FormatOptionsMemberX12 

type FormatOptionsMemberX12 struct {
	Value X12Details
	// contains filtered or unexported fields
}

A structure that contains the X12 transaction set and version. The X12 structure is used when the system transforms an EDI (electronic data interchange) file.

If an EDI input file contains more than one transaction, each transaction must have the same transaction set and version, for example 214/4010. If not, the transformer cannot parse the file.

type FromFormat 

type FromFormat string
const (
	FromFormatX12 FromFormat = "X12"
)

Enum values for FromFormat

func (FromFormat) Values 

func (FromFormat) Values() []FromFormat

Values returns all known values for FromFormat. Note that this can be expanded in the future, and so it is only as up to date as the client.

The ordering of this slice is not guaranteed to be stable across updates.

type InboundEdiOptions 

type InboundEdiOptions struct {

	// A structure that contains X12-specific options for processing inbound X12 EDI
	// files.
	X12 *X12InboundEdiOptions
	// contains filtered or unexported fields
}

Contains options for processing inbound EDI files. These options allow for customizing how incoming EDI documents are processed.

type InputConversion 

type InputConversion struct {

	// The format for the transformer input: currently on X12 is supported.
	//
	// This member is required.
	FromFormat FromFormat

	// Specifies advanced options for the input conversion process. These options
	// provide additional control over how EDI files are processed during
	// transformation.
	AdvancedOptions *AdvancedOptions

	// A structure that contains the formatting options for an inbound transformer.
	FormatOptions FormatOptions
	// contains filtered or unexported fields
}

Contains the input formatting options for an inbound transformer (takes an X12-formatted EDI document as input and converts it to JSON or XML.

type InputFileSource 

type InputFileSource interface {
	// contains filtered or unexported methods
}

The input file to use for an outbound transformation.

The following types satisfy this interface: 

InputFileSourceMemberFileContent
Example (OutputUsage) 
package main

import (
	"fmt"
	"github.com/aws/aws-sdk-go-v2/service/b2bi/types"
)

func main() {
	var union types.InputFileSource
	// type switches can be used to check the union value
	switch v := union.(type) {
	case *types.InputFileSourceMemberFileContent:
		_ = v.Value // Value is string

	case *types.UnknownUnionMember:
		fmt.Println("unknown tag:", v.Tag)

	default:
		fmt.Println("union is nil or unknown type")

	}
}

type InputFileSourceMemberFileContent 

type InputFileSourceMemberFileContent struct {
	Value string
	// contains filtered or unexported fields
}

Specify the input contents, as a string, for the source of an outbound transformation.

type InternalServerException 

type InternalServerException struct {
	Message *string

	ErrorCodeOverride *string

	RetryAfterSeconds *int32
	// contains filtered or unexported fields
}

This exception is thrown when an error occurs in the Amazon Web Services B2B Data Interchange service.

func (*InternalServerException) Error 

func (e *InternalServerException) Error() string

func (*InternalServerException) ErrorCode 

func (e *InternalServerException) ErrorCode() string

func (*InternalServerException) ErrorFault 

func (e *InternalServerException) ErrorFault() smithy.ErrorFault

func (*InternalServerException) ErrorMessage 

func (e *InternalServerException) ErrorMessage() string

type LineTerminator 

type LineTerminator string
const (
	LineTerminatorCrlf LineTerminator = "CRLF"
	LineTerminatorLf   LineTerminator = "LF"
	LineTerminatorCr   LineTerminator = "CR"
)

Enum values for LineTerminator

func (LineTerminator) Values 

func (LineTerminator) Values() []LineTerminator

Values returns all known values for LineTerminator. Note that this can be expanded in the future, and so it is only as up to date as the client.

The ordering of this slice is not guaranteed to be stable across updates.

type Logging 

type Logging string
const (
	LoggingEnabled  Logging = "ENABLED"
	LoggingDisabled Logging = "DISABLED"
)

Enum values for Logging

func (Logging) Values 

func (Logging) Values() []Logging

Values returns all known values for Logging. Note that this can be expanded in the future, and so it is only as up to date as the client.

The ordering of this slice is not guaranteed to be stable across updates.

type Mapping 

type Mapping struct {

	// The transformation language for the template, either XSLT or JSONATA.
	//
	// This member is required.
	TemplateLanguage MappingTemplateLanguage

	// A string that represents the mapping template, in the transformation language
	// specified in templateLanguage .
	Template *string
	// contains filtered or unexported fields
}

Specifies the mapping template for the transformer. This template is used to map the parsed EDI file using JSONata or XSLT.

type MappingTemplateLanguage 

type MappingTemplateLanguage string
const (
	MappingTemplateLanguageXslt    MappingTemplateLanguage = "XSLT"
	MappingTemplateLanguageJsonata MappingTemplateLanguage = "JSONATA"
)

Enum values for MappingTemplateLanguage

func (MappingTemplateLanguage) Values 

func (MappingTemplateLanguage) Values() []MappingTemplateLanguage

Values returns all known values for MappingTemplateLanguage. Note that this can be expanded in the future, and so it is only as up to date as the client.

The ordering of this slice is not guaranteed to be stable across updates.

type MappingType 

type MappingType string
const (
	MappingTypeJsonata MappingType = "JSONATA"
	MappingTypeXslt    MappingType = "XSLT"
)

Enum values for MappingType

func (MappingType) Values 

func (MappingType) Values() []MappingType

Values returns all known values for MappingType. Note that this can be expanded in the future, and so it is only as up to date as the client.

The ordering of this slice is not guaranteed to be stable across updates.

type OutboundEdiOptions 

type OutboundEdiOptions interface {
	// contains filtered or unexported methods
}

A container for outbound EDI options.

The following types satisfy this interface: 

OutboundEdiOptionsMemberX12
Example (OutputUsage) 
package main

import (
	"fmt"
	"github.com/aws/aws-sdk-go-v2/service/b2bi/types"
)

func main() {
	var union types.OutboundEdiOptions
	// type switches can be used to check the union value
	switch v := union.(type) {
	case *types.OutboundEdiOptionsMemberX12:
		_ = v.Value // Value is types.X12Envelope

	case *types.UnknownUnionMember:
		fmt.Println("unknown tag:", v.Tag)

	default:
		fmt.Println("union is nil or unknown type")

	}
}

type OutboundEdiOptionsMemberX12 

type OutboundEdiOptionsMemberX12 struct {
	Value X12Envelope
	// contains filtered or unexported fields
}

A structure that contains an X12 envelope structure.

type OutputConversion 

type OutputConversion struct {

	// The format for the output from an outbound transformer: only X12 is currently
	// supported.
	//
	// This member is required.
	ToFormat ToFormat

	// A structure that contains advanced options for EDI processing. Currently, only
	// X12 advanced options are supported.
	AdvancedOptions *AdvancedOptions

	// A structure that contains the X12 transaction set and version for the
	// transformer output.
	FormatOptions FormatOptions
	// contains filtered or unexported fields
}

Contains the formatting options for an outbound transformer (takes JSON or XML as input and converts it to an EDI document (currently only X12 format is supported).

type OutputSampleFileSource 

type OutputSampleFileSource interface {
	// contains filtered or unexported methods
}

Container for the location of a sample file used for outbound transformations.

The following types satisfy this interface: 

OutputSampleFileSourceMemberFileLocation
Example (OutputUsage) 
package main

import (
	"fmt"
	"github.com/aws/aws-sdk-go-v2/service/b2bi/types"
)

func main() {
	var union types.OutputSampleFileSource
	// type switches can be used to check the union value
	switch v := union.(type) {
	case *types.OutputSampleFileSourceMemberFileLocation:
		_ = v.Value // Value is types.S3Location

	case *types.UnknownUnionMember:
		fmt.Println("unknown tag:", v.Tag)

	default:
		fmt.Println("union is nil or unknown type")

	}
}

type OutputSampleFileSourceMemberFileLocation 

type OutputSampleFileSourceMemberFileLocation struct {
	Value S3Location
	// contains filtered or unexported fields
}

Specifies the details for the Amazon S3 file location that is being used with Amazon Web Services B2B Data Interchange. File locations in Amazon S3 are identified using a combination of the bucket and key.

type PartnershipSummary 

type PartnershipSummary struct {

	// Returns a timestamp for creation date and time of the partnership.
	//
	// This member is required.
	CreatedAt *time.Time

	// Returns the unique, system-generated identifier for a partnership.
	//
	// This member is required.
	PartnershipId *string

	// Returns the unique, system-generated identifier for the profile connected to
	// this partnership.
	//
	// This member is required.
	ProfileId *string

	// Returns one or more capabilities associated with this partnership.
	Capabilities []string

	// Contains the details for an Outbound EDI capability.
	CapabilityOptions *CapabilityOptions

	// Returns a timestamp that identifies the most recent date and time that the
	// partnership was modified.
	ModifiedAt *time.Time

	// Returns the name of the partnership.
	Name *string

	// Returns the unique, system-generated identifier for a trading partner.
	TradingPartnerId *string
	// contains filtered or unexported fields
}

A structure that contains the details for a partnership. A partnership represents the connection between you and your trading partner. It ties together a profile and one or more trading capabilities.

type ProfileSummary 

type ProfileSummary struct {

	// Returns the name for the business associated with this profile.
	//
	// This member is required.
	BusinessName *string

	// Returns the timestamp for creation date and time of the profile.
	//
	// This member is required.
	CreatedAt *time.Time

	// Returns the display name for profile.
	//
	// This member is required.
	Name *string

	// Returns the unique, system-generated identifier for the profile.
	//
	// This member is required.
	ProfileId *string

	// Returns the name of the logging group.
	LogGroupName *string

	// Specifies whether or not logging is enabled for this profile.
	Logging Logging

	// Returns the timestamp that identifies the most recent date and time that the
	// profile was modified.
	ModifiedAt *time.Time
	// contains filtered or unexported fields
}

Contains the details for a profile. A profile is the mechanism used to create the concept of a private network.

type ResourceNotFoundException 

type ResourceNotFoundException struct {
	Message *string

	ErrorCodeOverride *string
	// contains filtered or unexported fields
}

Occurs when the requested resource does not exist, or cannot be found. In some cases, the resource exists in a region other than the region specified in the API call.

func (*ResourceNotFoundException) Error 

func (e *ResourceNotFoundException) Error() string

func (*ResourceNotFoundException) ErrorCode 

func (e *ResourceNotFoundException) ErrorCode() string

func (*ResourceNotFoundException) ErrorFault 

func (e *ResourceNotFoundException) ErrorFault() smithy.ErrorFault

func (*ResourceNotFoundException) ErrorMessage 

func (e *ResourceNotFoundException) ErrorMessage() string

type S3Location 

type S3Location struct {

	// Specifies the name of the Amazon S3 bucket.
	BucketName *string

	// Specifies the Amazon S3 key for the file location.
	Key *string
	// contains filtered or unexported fields
}

Specifies the details for the Amazon S3 file location that is being used with Amazon Web Services B2B Data Interchange. File locations in Amazon S3 are identified using a combination of the bucket and key.

type SampleDocumentKeys 

type SampleDocumentKeys struct {

	// An array of keys for your input sample documents.
	Input *string

	// An array of keys for your output sample documents.
	Output *string
	// contains filtered or unexported fields
}

An array of the Amazon S3 keys used to identify the location for your sample documents.

type SampleDocuments 

type SampleDocuments struct {

	// Contains the Amazon S3 bucket that is used to hold your sample documents.
	//
	// This member is required.
	BucketName *string

	// Contains an array of the Amazon S3 keys used to identify the location for your
	// sample documents.
	//
	// This member is required.
	Keys []SampleDocumentKeys
	// contains filtered or unexported fields
}

Describes a structure that contains the Amazon S3 bucket and an array of the corresponding keys used to identify the location for your sample documents.

type ServiceQuotaExceededException 

type ServiceQuotaExceededException struct {
	Message *string

	ErrorCodeOverride *string

	ResourceId   *string
	ResourceType *string
	ServiceCode  *string
	QuotaCode    *string
	// contains filtered or unexported fields
}

Occurs when the calling command attempts to exceed one of the service quotas, for example trying to create a capability when you already have the maximum number of capabilities allowed.

func (*ServiceQuotaExceededException) Error 

func (e *ServiceQuotaExceededException) Error() string

func (*ServiceQuotaExceededException) ErrorCode 

func (e *ServiceQuotaExceededException) ErrorCode() string

func (*ServiceQuotaExceededException) ErrorFault 

func (e *ServiceQuotaExceededException) ErrorFault() smithy.ErrorFault

func (*ServiceQuotaExceededException) ErrorMessage 

func (e *ServiceQuotaExceededException) ErrorMessage() string

type Tag 

type Tag struct {

	// Specifies the name assigned to the tag that you create.
	//
	// This member is required.
	Key *string

	// Contains one or more values that you assigned to the key name that you create.
	//
	// This member is required.
	Value *string
	// contains filtered or unexported fields
}

Creates a key-value pair for a specific resource. Tags are metadata that you can use to search for and group a resource for various purposes. You can apply tags to capabilities, partnerships, profiles and transformers. A tag key can take more than one value. For example, to group capabilities for accounting purposes, you might create a tag called Group and assign the values Research and Accounting to that group.

type TemplateDetails 

type TemplateDetails interface {
	// contains filtered or unexported methods
}

A data structure that contains the information to use when generating a mapping template.

The following types satisfy this interface: 

TemplateDetailsMemberX12
Example (OutputUsage) 
package main

import (
	"fmt"
	"github.com/aws/aws-sdk-go-v2/service/b2bi/types"
)

func main() {
	var union types.TemplateDetails
	// type switches can be used to check the union value
	switch v := union.(type) {
	case *types.TemplateDetailsMemberX12:
		_ = v.Value // Value is types.X12Details

	case *types.UnknownUnionMember:
		fmt.Println("unknown tag:", v.Tag)

	default:
		fmt.Println("union is nil or unknown type")

	}
}

type TemplateDetailsMemberX12 

type TemplateDetailsMemberX12 struct {
	Value X12Details
	// contains filtered or unexported fields
}

A structure that contains the X12 transaction set and version. The X12 structure is used when the system transforms an EDI (electronic data interchange) file.

If an EDI input file contains more than one transaction, each transaction must have the same transaction set and version, for example 214/4010. If not, the transformer cannot parse the file.

type ThrottlingException 

type ThrottlingException struct {
	Message *string

	ErrorCodeOverride *string

	RetryAfterSeconds *int32
	// contains filtered or unexported fields
}

The request was denied due to throttling: the data speed and rendering may be limited depending on various parameters and conditions.

func (*ThrottlingException) Error 

func (e *ThrottlingException) Error() string

func (*ThrottlingException) ErrorCode 

func (e *ThrottlingException) ErrorCode() string

func (*ThrottlingException) ErrorFault 

func (e *ThrottlingException) ErrorFault() smithy.ErrorFault

func (*ThrottlingException) ErrorMessage 

func (e *ThrottlingException) ErrorMessage() string

type ToFormat 

type ToFormat string
const (
	ToFormatX12 ToFormat = "X12"
)

Enum values for ToFormat

func (ToFormat) Values 

func (ToFormat) Values() []ToFormat

Values returns all known values for ToFormat. Note that this can be expanded in the future, and so it is only as up to date as the client.

The ordering of this slice is not guaranteed to be stable across updates.

type TransformerJobStatus 

type TransformerJobStatus string
const (
	TransformerJobStatusRunning   TransformerJobStatus = "running"
	TransformerJobStatusSucceeded TransformerJobStatus = "succeeded"
	TransformerJobStatusFailed    TransformerJobStatus = "failed"
)

Enum values for TransformerJobStatus

func (TransformerJobStatus) Values 

func (TransformerJobStatus) Values() []TransformerJobStatus

Values returns all known values for TransformerJobStatus. Note that this can be expanded in the future, and so it is only as up to date as the client.

The ordering of this slice is not guaranteed to be stable across updates.

type TransformerStatus 

type TransformerStatus string
const (
	TransformerStatusActive   TransformerStatus = "active"
	TransformerStatusInactive TransformerStatus = "inactive"
)

Enum values for TransformerStatus

func (TransformerStatus) Values 

func (TransformerStatus) Values() []TransformerStatus

Values returns all known values for TransformerStatus. Note that this can be expanded in the future, and so it is only as up to date as the client.

The ordering of this slice is not guaranteed to be stable across updates.

type TransformerSummary 

type TransformerSummary struct {

	// Returns a timestamp indicating when the transformer was created. For example,
	// 2023-07-20T19:58:44.624Z .
	//
	// This member is required.
	CreatedAt *time.Time

	// Returns the descriptive name for the transformer.
	//
	// This member is required.
	Name *string

	// Returns the state of the newly created transformer. The transformer can be
	// either active or inactive . For the transformer to be used in a capability, its
	// status must active .
	//
	// This member is required.
	Status TransformerStatus

	// Returns the system-assigned unique identifier for the transformer.
	//
	// This member is required.
	TransformerId *string

	// Returns the details for the EDI standard that is being used for the
	// transformer. Currently, only X12 is supported. X12 is a set of standards and
	// corresponding messages that define specific business documents.
	//
	// Deprecated: This is a legacy trait. Please use input-conversion or
	// output-conversion.
	EdiType EdiType

	// Returns that the currently supported file formats for EDI transformations are
	// JSON and XML .
	//
	// Deprecated: This is a legacy trait. Please use input-conversion or
	// output-conversion.
	FileFormat FileFormat

	// Returns a structure that contains the format options for the transformation.
	InputConversion *InputConversion

	// Returns the structure that contains the mapping template and its language
	// (either XSLT or JSONATA).
	Mapping *Mapping

	// Returns the mapping template for the transformer. This template is used to map
	// the parsed EDI file using JSONata or XSLT.
	//
	// Deprecated: This is a legacy trait. Please use input-conversion or
	// output-conversion.
	MappingTemplate *string

	// Returns a timestamp representing the date and time for the most recent change
	// for the transformer object.
	ModifiedAt *time.Time

	// Returns the OutputConversion object, which contains the format options for the
	// outbound transformation.
	OutputConversion *OutputConversion

	// Returns a sample EDI document that is used by a transformer as a guide for
	// processing the EDI data.
	//
	// Deprecated: This is a legacy trait. Please use input-conversion or
	// output-conversion.
	SampleDocument *string

	// Returns a structure that contains the Amazon S3 bucket and an array of the
	// corresponding keys used to identify the location for your sample documents.
	SampleDocuments *SampleDocuments
	// contains filtered or unexported fields
}

Contains the details for a transformer object. A transformer can take an EDI file as input and transform it into a JSON-or XML-formatted document. Alternatively, a transformer can take a JSON-or XML-formatted document as input and transform it into an EDI file.

type UnknownUnionMember 

type UnknownUnionMember struct {
	Tag   string
	Value []byte
	// contains filtered or unexported fields
}

UnknownUnionMember is returned when a union member is returned over the wire, but has an unknown tag.

type ValidationException 

type ValidationException struct {
	Message *string

	ErrorCodeOverride *string
	// contains filtered or unexported fields
}

Occurs when a B2BI object cannot be validated against a request from another object. This exception can be thrown during standard EDI validation or when custom validation rules fail, such as when element length constraints are violated, invalid codes are used in code list validations, or required elements are missing based on configured element requirement rules.

func (*ValidationException) Error 

func (e *ValidationException) Error() string

func (*ValidationException) ErrorCode 

func (e *ValidationException) ErrorCode() string

func (*ValidationException) ErrorFault 

func (e *ValidationException) ErrorFault() smithy.ErrorFault

func (*ValidationException) ErrorMessage 

func (e *ValidationException) ErrorMessage() string

type WrapFormat 

type WrapFormat string
const (
	WrapFormatSegment    WrapFormat = "SEGMENT"
	WrapFormatOneLine    WrapFormat = "ONE_LINE"
	WrapFormatLineLength WrapFormat = "LINE_LENGTH"
)

Enum values for WrapFormat

func (WrapFormat) Values 

func (WrapFormat) Values() []WrapFormat

Values returns all known values for WrapFormat. Note that this can be expanded in the future, and so it is only as up to date as the client.

The ordering of this slice is not guaranteed to be stable across updates.

type WrapOptions 

type WrapOptions struct {

	// Specifies the method used for wrapping lines in the EDI output. Valid values:
	//
	//   - SEGMENT : Wraps by segment.
	//
	//   - ONE_LINE : Indicates that the entire content is on a single line.
	//
	// When you specify ONE_LINE , do not provide either the line length nor the line
	//   terminator value.
	//
	//   - LINE_LENGTH : Wraps by character count, as specified by lineLength value.
	//
	// This member is required.
	WrapBy WrapFormat

	// Specifies the maximum length of a line before wrapping occurs. This value is
	// used when wrapBy is set to LINE_LENGTH .
	LineLength *int32

	// Specifies the character sequence used to terminate lines when wrapping. Valid
	// values:
	//
	//   - CRLF : carriage return and line feed
	//
	//   - LF : line feed)
	//
	//   - CR : carriage return
	LineTerminator LineTerminator
	// contains filtered or unexported fields
}

Contains options for wrapping (line folding) in X12 EDI files. Wrapping controls how long lines are handled in the EDI output.

type X12AcknowledgmentOptions 

type X12AcknowledgmentOptions struct {

	// Specifies whether functional acknowledgments (997/999) should be generated for
	// incoming X12 transactions. Valid values are DO_NOT_GENERATE ,
	// GENERATE_ALL_SEGMENTS and GENERATE_WITHOUT_TRANSACTION_SET_RESPONSE_LOOP .
	//
	// If you choose GENERATE_WITHOUT_TRANSACTION_SET_RESPONSE_LOOP , Amazon Web
	// Services B2B Data Interchange skips the AK2_Loop when generating an
	// acknowledgment document.
	//
	// This member is required.
	FunctionalAcknowledgment X12FunctionalAcknowledgment

	// Specifies whether technical acknowledgments (TA1) should be generated for
	// incoming X12 interchanges. Valid values are DO_NOT_GENERATE and
	// GENERATE_ALL_SEGMENTS and.
	//
	// This member is required.
	TechnicalAcknowledgment X12TechnicalAcknowledgment
	// contains filtered or unexported fields
}

Contains options for configuring X12 acknowledgments. These options control how functional and technical acknowledgments are handled.

type X12AdvancedOptions 

type X12AdvancedOptions struct {

	// Specifies options for splitting X12 EDI files. These options control how large
	// X12 files are divided into smaller, more manageable units.
	SplitOptions *X12SplitOptions

	// Specifies validation options for X12 EDI processing. These options control how
	// validation rules are applied during EDI document processing, including custom
	// validation rules for element length constraints, code list validations, and
	// element requirement checks.
	ValidationOptions *X12ValidationOptions
	// contains filtered or unexported fields
}

Contains advanced options specific to X12 EDI processing, such as splitting large X12 files into smaller units.

type X12CodeListValidationRule 

type X12CodeListValidationRule struct {

	// Specifies the four-digit element ID to which the code list modifications apply.
	// This identifies which X12 element will have its allowed code values modified.
	//
	// This member is required.
	ElementId *string

	// Specifies a list of code values to add to the element's allowed values. These
	// codes will be considered valid for the specified element in addition to the
	// standard codes defined by the X12 specification.
	CodesToAdd []string

	// Specifies a list of code values to remove from the element's allowed values.
	// These codes will be considered invalid for the specified element, even if they
	// are part of the standard codes defined by the X12 specification.
	CodesToRemove []string
	// contains filtered or unexported fields
}

Defines a validation rule that modifies the allowed code values for a specific X12 element. This rule allows you to add or remove valid codes from an element's standard code list, providing flexibility to accommodate trading partner-specific requirements or industry variations. You can specify codes to add to expand the allowed values beyond the X12 standard, or codes to remove to restrict the allowed values for stricter validation.

type X12ControlNumbers 

type X12ControlNumbers struct {

	// Specifies the starting functional group control number (GS06) to use for X12
	// EDI generation. This number is incremented for each new functional group. For
	// the GS (functional group) envelope, Amazon Web Services B2B Data Interchange
	// generates a functional group control number that is unique to the sender ID,
	// receiver ID, and functional identifier code combination.
	StartingFunctionalGroupControlNumber *int32

	// Specifies the starting interchange control number (ISA13) to use for X12 EDI
	// generation. This number is incremented for each new interchange. For the ISA
	// (interchange) envelope, Amazon Web Services B2B Data Interchange generates an
	// interchange control number that is unique for the ISA05 and ISA06 (sender) &
	// ISA07 and ISA08 (receiver) combination.
	StartingInterchangeControlNumber *int32

	// Specifies the starting transaction set control number (ST02) to use for X12 EDI
	// generation. This number is incremented for each new transaction set.
	StartingTransactionSetControlNumber *int32
	// contains filtered or unexported fields
}

Contains configuration for X12 control numbers used in X12 EDI generation. Control numbers are used to uniquely identify interchanges, functional groups, and transaction sets.

type X12Delimiters 

type X12Delimiters struct {

	// The component, or sub-element, separator. The default value is : (colon).
	ComponentSeparator *string

	// The data element separator. The default value is * (asterisk).
	DataElementSeparator *string

	// The segment terminator. The default value is ~ (tilde).
	SegmentTerminator *string
	// contains filtered or unexported fields
}

In X12 EDI messages, delimiters are used to mark the end of segments or elements, and are defined in the interchange control header. The delimiters are part of the message's syntax and divide up its different elements.

type X12Details 

type X12Details struct {

	// Returns an enumerated type where each value identifies an X12 transaction set.
	// Transaction sets are maintained by the X12 Accredited Standards Committee.
	TransactionSet X12TransactionSet

	// Returns the version to use for the specified X12 transaction set.
	Version X12Version
	// contains filtered or unexported fields
}

A structure that contains the X12 transaction set and version. The X12 structure is used when the system transforms an EDI (electronic data interchange) file.

If an EDI input file contains more than one transaction, each transaction must have the same transaction set and version, for example 214/4010. If not, the transformer cannot parse the file.

type X12ElementLengthValidationRule 

type X12ElementLengthValidationRule struct {

	// Specifies the four-digit element ID to which the length constraints will be
	// applied. This identifies which X12 element will have its length requirements
	// modified.
	//
	// This member is required.
	ElementId *string

	// Specifies the maximum allowed length for the identified element. This value
	// must be between 1 and 200 characters and defines the upper limit for the
	// element's content length.
	//
	// This member is required.
	MaxLength *int32

	// Specifies the minimum required length for the identified element. This value
	// must be between 1 and 200 characters and defines the lower limit for the
	// element's content length.
	//
	// This member is required.
	MinLength *int32
	// contains filtered or unexported fields
}

Defines a validation rule that specifies custom length constraints for a specific X12 element. This rule allows you to override the standard minimum and maximum length requirements for an element, enabling validation of trading partner-specific length requirements that may differ from the X12 specification. Both minimum and maximum length values must be specified and must be between 1 and 200 characters.

type X12ElementRequirementValidationRule 

type X12ElementRequirementValidationRule struct {

	// Specifies the position of the element within an X12 segment for which the
	// requirement status will be modified. The format follows the pattern of segment
	// identifier followed by element position (e.g., "ST-01" for the first element of
	// the ST segment).
	//
	// This member is required.
	ElementPosition *string

	// Specifies the requirement status for the element at the specified position.
	// Valid values are OPTIONAL (the element may be omitted) or MANDATORY (the element
	// must be present).
	//
	// This member is required.
	Requirement ElementRequirement
	// contains filtered or unexported fields
}

Defines a validation rule that modifies the requirement status of a specific X12 element within a segment. This rule allows you to make optional elements mandatory or mandatory elements optional, providing flexibility to accommodate different trading partner requirements and business rules. The rule targets a specific element position within a segment and sets its requirement status to either OPTIONAL or MANDATORY.

type X12Envelope 

type X12Envelope struct {

	// A container for the X12 outbound EDI headers.
	Common *X12OutboundEdiHeaders

	// Contains options for wrapping (line folding) in X12 EDI files. Wrapping
	// controls how long lines are handled in the EDI output.
	WrapOptions *WrapOptions
	// contains filtered or unexported fields
}

A wrapper structure for an X12 definition object.

the X12 envelope ensures the integrity of the data and the efficiency of the information exchange. The X12 message structure has hierarchical levels. From highest to the lowest, they are:

  • Interchange Envelope

  • Functional Group

  • Transaction Set

type X12FunctionalAcknowledgment 

type X12FunctionalAcknowledgment string
const (
	X12FunctionalAcknowledgmentDoNotGenerate                             X12FunctionalAcknowledgment = "DO_NOT_GENERATE"
	X12FunctionalAcknowledgmentGenerateAllSegments                       X12FunctionalAcknowledgment = "GENERATE_ALL_SEGMENTS"
	X12FunctionalAcknowledgmentGenerateWithoutTransactionSetResponseLoop X12FunctionalAcknowledgment = "GENERATE_WITHOUT_TRANSACTION_SET_RESPONSE_LOOP"
)

Enum values for X12FunctionalAcknowledgment

func (X12FunctionalAcknowledgment) Values 

func (X12FunctionalAcknowledgment) Values() []X12FunctionalAcknowledgment

Values returns all known values for X12FunctionalAcknowledgment. Note that this can be expanded in the future, and so it is only as up to date as the client.

The ordering of this slice is not guaranteed to be stable across updates.

type X12FunctionalGroupHeaders 

type X12FunctionalGroupHeaders struct {

	// A value representing the code used to identify the party receiving a message,
	// at position GS-03.
	ApplicationReceiverCode *string

	// A value representing the code used to identify the party transmitting a
	// message, at position GS-02.
	ApplicationSenderCode *string

	// A code that identifies the issuer of the standard, at position GS-07.
	ResponsibleAgencyCode *string
	// contains filtered or unexported fields
}

Part of the X12 message structure. These are the functional group headers for the X12 EDI object.

type X12GS05TimeFormat 

type X12GS05TimeFormat string
const (
	X12GS05TimeFormatHhmm     X12GS05TimeFormat = "HHMM"
	X12GS05TimeFormatHhmmss   X12GS05TimeFormat = "HHMMSS"
	X12GS05TimeFormatHhmmssdd X12GS05TimeFormat = "HHMMSSDD"
)

Enum values for X12GS05TimeFormat

func (X12GS05TimeFormat) Values 

func (X12GS05TimeFormat) Values() []X12GS05TimeFormat

Values returns all known values for X12GS05TimeFormat. Note that this can be expanded in the future, and so it is only as up to date as the client.

The ordering of this slice is not guaranteed to be stable across updates.

type X12InboundEdiOptions 

type X12InboundEdiOptions struct {

	// Specifies acknowledgment options for inbound X12 EDI files. These options
	// control how functional and technical acknowledgments are handled.
	AcknowledgmentOptions *X12AcknowledgmentOptions
	// contains filtered or unexported fields
}

Contains options specific to processing inbound X12 EDI files.

type X12InterchangeControlHeaders 

type X12InterchangeControlHeaders struct {

	// Located at position ISA-14 in the header. The value "1" indicates that the
	// sender is requesting an interchange acknowledgment at receipt of the
	// interchange. The value "0" is used otherwise.
	AcknowledgmentRequestedCode *string

	// Located at position ISA-08 in the header. This value (along with the
	// receiverIdQualifier ) identifies the intended recipient of the interchange.
	ReceiverId *string

	// Located at position ISA-07 in the header. Qualifier for the receiver ID.
	// Together, the ID and qualifier uniquely identify the receiving trading partner.
	ReceiverIdQualifier *string

	// Located at position ISA-11 in the header. This string makes it easier when you
	// need to group similar adjacent element values together without using extra
	// segments.
	//
	// This parameter is only honored for version greater than 401 ( VERSION_4010 and
	// higher).
	//
	// For versions less than 401, this field is called [StandardsId], in which case our service
	// sets the value to U .
	//
	// [StandardsId]: https://www.stedi.com/edi/x12-004010/segment/ISA#ISA-11
	RepetitionSeparator *string

	// Located at position ISA-06 in the header. This value (along with the
	// senderIdQualifier ) identifies the sender of the interchange.
	SenderId *string

	// Located at position ISA-05 in the header. Qualifier for the sender ID.
	// Together, the ID and qualifier uniquely identify the sending trading partner.
	SenderIdQualifier *string

	// Located at position ISA-15 in the header. Specifies how this interchange is
	// being used:
	//
	//   - T indicates this interchange is for testing.
	//
	//   - P indicates this interchange is for production.
	//
	//   - I indicates this interchange is informational.
	UsageIndicatorCode *string
	// contains filtered or unexported fields
}

In X12, the Interchange Control Header is the first segment of an EDI document and is part of the Interchange Envelope. It contains information about the sender and receiver, the date and time of transmission, and the X12 version being used. It also includes delivery information, such as the sender and receiver IDs.

type X12OutboundEdiHeaders 

type X12OutboundEdiHeaders struct {

	// Specifies control number configuration for outbound X12 EDI headers. These
	// settings determine the starting values for interchange, functional group, and
	// transaction set control numbers.
	ControlNumbers *X12ControlNumbers

	// The delimiters, for example semicolon ( ; ), that separates sections of the
	// headers for the X12 object.
	Delimiters *X12Delimiters

	// The functional group headers for the X12 object.
	FunctionalGroupHeaders *X12FunctionalGroupHeaders

	// Specifies the time format in the GS05 element (time) of the functional group
	// header. The following formats use 24-hour clock time:
	//
	//   - HHMM - Hours and minutes
	//
	//   - HHMMSS - Hours, minutes, and seconds
	//
	//   - HHMMSSDD - Hours, minutes, seconds, and decimal seconds
	//
	// Where:
	//
	//   - HH - Hours (00-23)
	//
	//   - MM - Minutes (00-59)
	//
	//   - SS - Seconds (00-59)
	//
	//   - DD - Hundredths of seconds (00-99)
	Gs05TimeFormat X12GS05TimeFormat

	// In X12 EDI messages, delimiters are used to mark the end of segments or
	// elements, and are defined in the interchange control header.
	InterchangeControlHeaders *X12InterchangeControlHeaders

	// Specifies whether or not to validate the EDI for this X12 object: TRUE or FALSE
	// . When enabled, this performs both standard EDI validation and applies any
	// configured custom validation rules including element length constraints, code
	// list validations, and element requirement checks. Validation results are
	// returned in the response validation messages.
	ValidateEdi *bool
	// contains filtered or unexported fields
}

A structure containing the details for an outbound EDI object.

type X12SplitBy 

type X12SplitBy string
const (
	X12SplitByNone        X12SplitBy = "NONE"
	X12SplitByTransaction X12SplitBy = "TRANSACTION"
)

Enum values for X12SplitBy

func (X12SplitBy) Values 

func (X12SplitBy) Values() []X12SplitBy

Values returns all known values for X12SplitBy. Note that this can be expanded in the future, and so it is only as up to date as the client.

The ordering of this slice is not guaranteed to be stable across updates.

type X12SplitOptions 

type X12SplitOptions struct {

	// Specifies the method used to split X12 EDI files. Valid values include
	// TRANSACTION (split by individual transaction sets), or NONE (no splitting).
	//
	// This member is required.
	SplitBy X12SplitBy
	// contains filtered or unexported fields
}

Contains options for splitting X12 EDI files into smaller units. This is useful for processing large EDI files more efficiently.

type X12TechnicalAcknowledgment 

type X12TechnicalAcknowledgment string
const (
	X12TechnicalAcknowledgmentDoNotGenerate       X12TechnicalAcknowledgment = "DO_NOT_GENERATE"
	X12TechnicalAcknowledgmentGenerateAllSegments X12TechnicalAcknowledgment = "GENERATE_ALL_SEGMENTS"
)

Enum values for X12TechnicalAcknowledgment

func (X12TechnicalAcknowledgment) Values 

func (X12TechnicalAcknowledgment) Values() []X12TechnicalAcknowledgment

Values returns all known values for X12TechnicalAcknowledgment. Note that this can be expanded in the future, and so it is only as up to date as the client.

The ordering of this slice is not guaranteed to be stable across updates.

type X12TransactionSet 

type X12TransactionSet string
const (
	X12TransactionSetX12100     X12TransactionSet = "X12_100"
	X12TransactionSetX12101     X12TransactionSet = "X12_101"
	X12TransactionSetX12102     X12TransactionSet = "X12_102"
	X12TransactionSetX12103     X12TransactionSet = "X12_103"
	X12TransactionSetX12104     X12TransactionSet = "X12_104"
	X12TransactionSetX12105     X12TransactionSet = "X12_105"
	X12TransactionSetX12106     X12TransactionSet = "X12_106"
	X12TransactionSetX12107     X12TransactionSet = "X12_107"
	X12TransactionSetX12108     X12TransactionSet = "X12_108"
	X12TransactionSetX12109     X12TransactionSet = "X12_109"
	X12TransactionSetX12110     X12TransactionSet = "X12_110"
	X12TransactionSetX12111     X12TransactionSet = "X12_111"
	X12TransactionSetX12112     X12TransactionSet = "X12_112"
	X12TransactionSetX12113     X12TransactionSet = "X12_113"
	X12TransactionSetX12120     X12TransactionSet = "X12_120"
	X12TransactionSetX12121     X12TransactionSet = "X12_121"
	X12TransactionSetX12124     X12TransactionSet = "X12_124"
	X12TransactionSetX12125     X12TransactionSet = "X12_125"
	X12TransactionSetX12126     X12TransactionSet = "X12_126"
	X12TransactionSetX12127     X12TransactionSet = "X12_127"
	X12TransactionSetX12128     X12TransactionSet = "X12_128"
	X12TransactionSetX12129     X12TransactionSet = "X12_129"
	X12TransactionSetX12130     X12TransactionSet = "X12_130"
	X12TransactionSetX12131     X12TransactionSet = "X12_131"
	X12TransactionSetX12132     X12TransactionSet = "X12_132"
	X12TransactionSetX12133     X12TransactionSet = "X12_133"
	X12TransactionSetX12135     X12TransactionSet = "X12_135"
	X12TransactionSetX12138     X12TransactionSet = "X12_138"
	X12TransactionSetX12139     X12TransactionSet = "X12_139"
	X12TransactionSetX12140     X12TransactionSet = "X12_140"
	X12TransactionSetX12141     X12TransactionSet = "X12_141"
	X12TransactionSetX12142     X12TransactionSet = "X12_142"
	X12TransactionSetX12143     X12TransactionSet = "X12_143"
	X12TransactionSetX12144     X12TransactionSet = "X12_144"
	X12TransactionSetX12146     X12TransactionSet = "X12_146"
	X12TransactionSetX12147     X12TransactionSet = "X12_147"
	X12TransactionSetX12148     X12TransactionSet = "X12_148"
	X12TransactionSetX12149     X12TransactionSet = "X12_149"
	X12TransactionSetX12150     X12TransactionSet = "X12_150"
	X12TransactionSetX12151     X12TransactionSet = "X12_151"
	X12TransactionSetX12152     X12TransactionSet = "X12_152"
	X12TransactionSetX12153     X12TransactionSet = "X12_153"
	X12TransactionSetX12154     X12TransactionSet = "X12_154"
	X12TransactionSetX12155     X12TransactionSet = "X12_155"
	X12TransactionSetX12157     X12TransactionSet = "X12_157"
	X12TransactionSetX12158     X12TransactionSet = "X12_158"
	X12TransactionSetX12159     X12TransactionSet = "X12_159"
	X12TransactionSetX12160     X12TransactionSet = "X12_160"
	X12TransactionSetX12161     X12TransactionSet = "X12_161"
	X12TransactionSetX12163     X12TransactionSet = "X12_163"
	X12TransactionSetX12170     X12TransactionSet = "X12_170"
	X12TransactionSetX12175     X12TransactionSet = "X12_175"
	X12TransactionSetX12176     X12TransactionSet = "X12_176"
	X12TransactionSetX12179     X12TransactionSet = "X12_179"
	X12TransactionSetX12180     X12TransactionSet = "X12_180"
	X12TransactionSetX12185     X12TransactionSet = "X12_185"
	X12TransactionSetX12186     X12TransactionSet = "X12_186"
	X12TransactionSetX12187     X12TransactionSet = "X12_187"
	X12TransactionSetX12188     X12TransactionSet = "X12_188"
	X12TransactionSetX12189     X12TransactionSet = "X12_189"
	X12TransactionSetX12190     X12TransactionSet = "X12_190"
	X12TransactionSetX12191     X12TransactionSet = "X12_191"
	X12TransactionSetX12194     X12TransactionSet = "X12_194"
	X12TransactionSetX12195     X12TransactionSet = "X12_195"
	X12TransactionSetX12196     X12TransactionSet = "X12_196"
	X12TransactionSetX12197     X12TransactionSet = "X12_197"
	X12TransactionSetX12198     X12TransactionSet = "X12_198"
	X12TransactionSetX12199     X12TransactionSet = "X12_199"
	X12TransactionSetX12200     X12TransactionSet = "X12_200"
	X12TransactionSetX12201     X12TransactionSet = "X12_201"
	X12TransactionSetX12202     X12TransactionSet = "X12_202"
	X12TransactionSetX12203     X12TransactionSet = "X12_203"
	X12TransactionSetX12204     X12TransactionSet = "X12_204"
	X12TransactionSetX12205     X12TransactionSet = "X12_205"
	X12TransactionSetX12206     X12TransactionSet = "X12_206"
	X12TransactionSetX12210     X12TransactionSet = "X12_210"
	X12TransactionSetX12211     X12TransactionSet = "X12_211"
	X12TransactionSetX12212     X12TransactionSet = "X12_212"
	X12TransactionSetX12213     X12TransactionSet = "X12_213"
	X12TransactionSetX12214     X12TransactionSet = "X12_214"
	X12TransactionSetX12215     X12TransactionSet = "X12_215"
	X12TransactionSetX12216     X12TransactionSet = "X12_216"
	X12TransactionSetX12217     X12TransactionSet = "X12_217"
	X12TransactionSetX12218     X12TransactionSet = "X12_218"
	X12TransactionSetX12219     X12TransactionSet = "X12_219"
	X12TransactionSetX12220     X12TransactionSet = "X12_220"
	X12TransactionSetX12222     X12TransactionSet = "X12_222"
	X12TransactionSetX12223     X12TransactionSet = "X12_223"
	X12TransactionSetX12224     X12TransactionSet = "X12_224"
	X12TransactionSetX12225     X12TransactionSet = "X12_225"
	X12TransactionSetX12227     X12TransactionSet = "X12_227"
	X12TransactionSetX12228     X12TransactionSet = "X12_228"
	X12TransactionSetX12240     X12TransactionSet = "X12_240"
	X12TransactionSetX12242     X12TransactionSet = "X12_242"
	X12TransactionSetX12244     X12TransactionSet = "X12_244"
	X12TransactionSetX12245     X12TransactionSet = "X12_245"
	X12TransactionSetX12248     X12TransactionSet = "X12_248"
	X12TransactionSetX12249     X12TransactionSet = "X12_249"
	X12TransactionSetX12250     X12TransactionSet = "X12_250"
	X12TransactionSetX12251     X12TransactionSet = "X12_251"
	X12TransactionSetX12252     X12TransactionSet = "X12_252"
	X12TransactionSetX12255     X12TransactionSet = "X12_255"
	X12TransactionSetX12256     X12TransactionSet = "X12_256"
	X12TransactionSetX12259     X12TransactionSet = "X12_259"
	X12TransactionSetX12260     X12TransactionSet = "X12_260"
	X12TransactionSetX12261     X12TransactionSet = "X12_261"
	X12TransactionSetX12262     X12TransactionSet = "X12_262"
	X12TransactionSetX12263     X12TransactionSet = "X12_263"
	X12TransactionSetX12264     X12TransactionSet = "X12_264"
	X12TransactionSetX12265     X12TransactionSet = "X12_265"
	X12TransactionSetX12266     X12TransactionSet = "X12_266"
	X12TransactionSetX12267     X12TransactionSet = "X12_267"
	X12TransactionSetX12268     X12TransactionSet = "X12_268"
	X12TransactionSetX12269     X12TransactionSet = "X12_269"
	X12TransactionSetX12270     X12TransactionSet = "X12_270"
	X12TransactionSetX12271     X12TransactionSet = "X12_271"
	X12TransactionSetX12272     X12TransactionSet = "X12_272"
	X12TransactionSetX12273     X12TransactionSet = "X12_273"
	X12TransactionSetX12274     X12TransactionSet = "X12_274"
	X12TransactionSetX12275     X12TransactionSet = "X12_275"
	X12TransactionSetX12276     X12TransactionSet = "X12_276"
	X12TransactionSetX12277     X12TransactionSet = "X12_277"
	X12TransactionSetX12278     X12TransactionSet = "X12_278"
	X12TransactionSetX12280     X12TransactionSet = "X12_280"
	X12TransactionSetX12283     X12TransactionSet = "X12_283"
	X12TransactionSetX12284     X12TransactionSet = "X12_284"
	X12TransactionSetX12285     X12TransactionSet = "X12_285"
	X12TransactionSetX12286     X12TransactionSet = "X12_286"
	X12TransactionSetX12288     X12TransactionSet = "X12_288"
	X12TransactionSetX12290     X12TransactionSet = "X12_290"
	X12TransactionSetX12300     X12TransactionSet = "X12_300"
	X12TransactionSetX12301     X12TransactionSet = "X12_301"
	X12TransactionSetX12303     X12TransactionSet = "X12_303"
	X12TransactionSetX12304     X12TransactionSet = "X12_304"
	X12TransactionSetX12309     X12TransactionSet = "X12_309"
	X12TransactionSetX12310     X12TransactionSet = "X12_310"
	X12TransactionSetX12311     X12TransactionSet = "X12_311"
	X12TransactionSetX12312     X12TransactionSet = "X12_312"
	X12TransactionSetX12313     X12TransactionSet = "X12_313"
	X12TransactionSetX12315     X12TransactionSet = "X12_315"
	X12TransactionSetX12317     X12TransactionSet = "X12_317"
	X12TransactionSetX12319     X12TransactionSet = "X12_319"
	X12TransactionSetX12322     X12TransactionSet = "X12_322"
	X12TransactionSetX12323     X12TransactionSet = "X12_323"
	X12TransactionSetX12324     X12TransactionSet = "X12_324"
	X12TransactionSetX12325     X12TransactionSet = "X12_325"
	X12TransactionSetX12326     X12TransactionSet = "X12_326"
	X12TransactionSetX12350     X12TransactionSet = "X12_350"
	X12TransactionSetX12352     X12TransactionSet = "X12_352"
	X12TransactionSetX12353     X12TransactionSet = "X12_353"
	X12TransactionSetX12354     X12TransactionSet = "X12_354"
	X12TransactionSetX12355     X12TransactionSet = "X12_355"
	X12TransactionSetX12356     X12TransactionSet = "X12_356"
	X12TransactionSetX12357     X12TransactionSet = "X12_357"
	X12TransactionSetX12358     X12TransactionSet = "X12_358"
	X12TransactionSetX12361     X12TransactionSet = "X12_361"
	X12TransactionSetX12362     X12TransactionSet = "X12_362"
	X12TransactionSetX12404     X12TransactionSet = "X12_404"
	X12TransactionSetX12410     X12TransactionSet = "X12_410"
	X12TransactionSetX12412     X12TransactionSet = "X12_412"
	X12TransactionSetX12414     X12TransactionSet = "X12_414"
	X12TransactionSetX12417     X12TransactionSet = "X12_417"
	X12TransactionSetX12418     X12TransactionSet = "X12_418"
	X12TransactionSetX12419     X12TransactionSet = "X12_419"
	X12TransactionSetX12420     X12TransactionSet = "X12_420"
	X12TransactionSetX12421     X12TransactionSet = "X12_421"
	X12TransactionSetX12422     X12TransactionSet = "X12_422"
	X12TransactionSetX12423     X12TransactionSet = "X12_423"
	X12TransactionSetX12424     X12TransactionSet = "X12_424"
	X12TransactionSetX12425     X12TransactionSet = "X12_425"
	X12TransactionSetX12426     X12TransactionSet = "X12_426"
	X12TransactionSetX12429     X12TransactionSet = "X12_429"
	X12TransactionSetX12431     X12TransactionSet = "X12_431"
	X12TransactionSetX12432     X12TransactionSet = "X12_432"
	X12TransactionSetX12433     X12TransactionSet = "X12_433"
	X12TransactionSetX12434     X12TransactionSet = "X12_434"
	X12TransactionSetX12435     X12TransactionSet = "X12_435"
	X12TransactionSetX12436     X12TransactionSet = "X12_436"
	X12TransactionSetX12437     X12TransactionSet = "X12_437"
	X12TransactionSetX12440     X12TransactionSet = "X12_440"
	X12TransactionSetX12451     X12TransactionSet = "X12_451"
	X12TransactionSetX12452     X12TransactionSet = "X12_452"
	X12TransactionSetX12453     X12TransactionSet = "X12_453"
	X12TransactionSetX12455     X12TransactionSet = "X12_455"
	X12TransactionSetX12456     X12TransactionSet = "X12_456"
	X12TransactionSetX12460     X12TransactionSet = "X12_460"
	X12TransactionSetX12463     X12TransactionSet = "X12_463"
	X12TransactionSetX12466     X12TransactionSet = "X12_466"
	X12TransactionSetX12468     X12TransactionSet = "X12_468"
	X12TransactionSetX12470     X12TransactionSet = "X12_470"
	X12TransactionSetX12475     X12TransactionSet = "X12_475"
	X12TransactionSetX12485     X12TransactionSet = "X12_485"
	X12TransactionSetX12486     X12TransactionSet = "X12_486"
	X12TransactionSetX12490     X12TransactionSet = "X12_490"
	X12TransactionSetX12492     X12TransactionSet = "X12_492"
	X12TransactionSetX12494     X12TransactionSet = "X12_494"
	X12TransactionSetX12500     X12TransactionSet = "X12_500"
	X12TransactionSetX12501     X12TransactionSet = "X12_501"
	X12TransactionSetX12503     X12TransactionSet = "X12_503"
	X12TransactionSetX12504     X12TransactionSet = "X12_504"
	X12TransactionSetX12511     X12TransactionSet = "X12_511"
	X12TransactionSetX12517     X12TransactionSet = "X12_517"
	X12TransactionSetX12521     X12TransactionSet = "X12_521"
	X12TransactionSetX12527     X12TransactionSet = "X12_527"
	X12TransactionSetX12536     X12TransactionSet = "X12_536"
	X12TransactionSetX12540     X12TransactionSet = "X12_540"
	X12TransactionSetX12561     X12TransactionSet = "X12_561"
	X12TransactionSetX12567     X12TransactionSet = "X12_567"
	X12TransactionSetX12568     X12TransactionSet = "X12_568"
	X12TransactionSetX12601     X12TransactionSet = "X12_601"
	X12TransactionSetX12602     X12TransactionSet = "X12_602"
	X12TransactionSetX12620     X12TransactionSet = "X12_620"
	X12TransactionSetX12625     X12TransactionSet = "X12_625"
	X12TransactionSetX12650     X12TransactionSet = "X12_650"
	X12TransactionSetX12715     X12TransactionSet = "X12_715"
	X12TransactionSetX12753     X12TransactionSet = "X12_753"
	X12TransactionSetX12754     X12TransactionSet = "X12_754"
	X12TransactionSetX12805     X12TransactionSet = "X12_805"
	X12TransactionSetX12806     X12TransactionSet = "X12_806"
	X12TransactionSetX12810     X12TransactionSet = "X12_810"
	X12TransactionSetX12811     X12TransactionSet = "X12_811"
	X12TransactionSetX12812     X12TransactionSet = "X12_812"
	X12TransactionSetX12813     X12TransactionSet = "X12_813"
	X12TransactionSetX12814     X12TransactionSet = "X12_814"
	X12TransactionSetX12815     X12TransactionSet = "X12_815"
	X12TransactionSetX12816     X12TransactionSet = "X12_816"
	X12TransactionSetX12818     X12TransactionSet = "X12_818"
	X12TransactionSetX12819     X12TransactionSet = "X12_819"
	X12TransactionSetX12820     X12TransactionSet = "X12_820"
	X12TransactionSetX12821     X12TransactionSet = "X12_821"
	X12TransactionSetX12822     X12TransactionSet = "X12_822"
	X12TransactionSetX12823     X12TransactionSet = "X12_823"
	X12TransactionSetX12824     X12TransactionSet = "X12_824"
	X12TransactionSetX12826     X12TransactionSet = "X12_826"
	X12TransactionSetX12827     X12TransactionSet = "X12_827"
	X12TransactionSetX12828     X12TransactionSet = "X12_828"
	X12TransactionSetX12829     X12TransactionSet = "X12_829"
	X12TransactionSetX12830     X12TransactionSet = "X12_830"
	X12TransactionSetX12831     X12TransactionSet = "X12_831"
	X12TransactionSetX12832     X12TransactionSet = "X12_832"
	X12TransactionSetX12833     X12TransactionSet = "X12_833"
	X12TransactionSetX12834     X12TransactionSet = "X12_834"
	X12TransactionSetX12835     X12TransactionSet = "X12_835"
	X12TransactionSetX12836     X12TransactionSet = "X12_836"
	X12TransactionSetX12837     X12TransactionSet = "X12_837"
	X12TransactionSetX12838     X12TransactionSet = "X12_838"
	X12TransactionSetX12839     X12TransactionSet = "X12_839"
	X12TransactionSetX12840     X12TransactionSet = "X12_840"
	X12TransactionSetX12841     X12TransactionSet = "X12_841"
	X12TransactionSetX12842     X12TransactionSet = "X12_842"
	X12TransactionSetX12843     X12TransactionSet = "X12_843"
	X12TransactionSetX12844     X12TransactionSet = "X12_844"
	X12TransactionSetX12845     X12TransactionSet = "X12_845"
	X12TransactionSetX12846     X12TransactionSet = "X12_846"
	X12TransactionSetX12847     X12TransactionSet = "X12_847"
	X12TransactionSetX12848     X12TransactionSet = "X12_848"
	X12TransactionSetX12849     X12TransactionSet = "X12_849"
	X12TransactionSetX12850     X12TransactionSet = "X12_850"
	X12TransactionSetX12851     X12TransactionSet = "X12_851"
	X12TransactionSetX12852     X12TransactionSet = "X12_852"
	X12TransactionSetX12853     X12TransactionSet = "X12_853"
	X12TransactionSetX12854     X12TransactionSet = "X12_854"
	X12TransactionSetX12855     X12TransactionSet = "X12_855"
	X12TransactionSetX12856     X12TransactionSet = "X12_856"
	X12TransactionSetX12857     X12TransactionSet = "X12_857"
	X12TransactionSetX12858     X12TransactionSet = "X12_858"
	X12TransactionSetX12859     X12TransactionSet = "X12_859"
	X12TransactionSetX12860     X12TransactionSet = "X12_860"
	X12TransactionSetX12861     X12TransactionSet = "X12_861"
	X12TransactionSetX12862     X12TransactionSet = "X12_862"
	X12TransactionSetX12863     X12TransactionSet = "X12_863"
	X12TransactionSetX12864     X12TransactionSet = "X12_864"
	X12TransactionSetX12865     X12TransactionSet = "X12_865"
	X12TransactionSetX12866     X12TransactionSet = "X12_866"
	X12TransactionSetX12867     X12TransactionSet = "X12_867"
	X12TransactionSetX12868     X12TransactionSet = "X12_868"
	X12TransactionSetX12869     X12TransactionSet = "X12_869"
	X12TransactionSetX12870     X12TransactionSet = "X12_870"
	X12TransactionSetX12871     X12TransactionSet = "X12_871"
	X12TransactionSetX12872     X12TransactionSet = "X12_872"
	X12TransactionSetX12873     X12TransactionSet = "X12_873"
	X12TransactionSetX12874     X12TransactionSet = "X12_874"
	X12TransactionSetX12875     X12TransactionSet = "X12_875"
	X12TransactionSetX12876     X12TransactionSet = "X12_876"
	X12TransactionSetX12877     X12TransactionSet = "X12_877"
	X12TransactionSetX12878     X12TransactionSet = "X12_878"
	X12TransactionSetX12879     X12TransactionSet = "X12_879"
	X12TransactionSetX12880     X12TransactionSet = "X12_880"
	X12TransactionSetX12881     X12TransactionSet = "X12_881"
	X12TransactionSetX12882     X12TransactionSet = "X12_882"
	X12TransactionSetX12883     X12TransactionSet = "X12_883"
	X12TransactionSetX12884     X12TransactionSet = "X12_884"
	X12TransactionSetX12885     X12TransactionSet = "X12_885"
	X12TransactionSetX12886     X12TransactionSet = "X12_886"
	X12TransactionSetX12887     X12TransactionSet = "X12_887"
	X12TransactionSetX12888     X12TransactionSet = "X12_888"
	X12TransactionSetX12889     X12TransactionSet = "X12_889"
	X12TransactionSetX12891     X12TransactionSet = "X12_891"
	X12TransactionSetX12893     X12TransactionSet = "X12_893"
	X12TransactionSetX12894     X12TransactionSet = "X12_894"
	X12TransactionSetX12895     X12TransactionSet = "X12_895"
	X12TransactionSetX12896     X12TransactionSet = "X12_896"
	X12TransactionSetX12920     X12TransactionSet = "X12_920"
	X12TransactionSetX12924     X12TransactionSet = "X12_924"
	X12TransactionSetX12925     X12TransactionSet = "X12_925"
	X12TransactionSetX12926     X12TransactionSet = "X12_926"
	X12TransactionSetX12928     X12TransactionSet = "X12_928"
	X12TransactionSetX12940     X12TransactionSet = "X12_940"
	X12TransactionSetX12943     X12TransactionSet = "X12_943"
	X12TransactionSetX12944     X12TransactionSet = "X12_944"
	X12TransactionSetX12945     X12TransactionSet = "X12_945"
	X12TransactionSetX12947     X12TransactionSet = "X12_947"
	X12TransactionSetX12980     X12TransactionSet = "X12_980"
	X12TransactionSetX12990     X12TransactionSet = "X12_990"
	X12TransactionSetX12993     X12TransactionSet = "X12_993"
	X12TransactionSetX12996     X12TransactionSet = "X12_996"
	X12TransactionSetX12997     X12TransactionSet = "X12_997"
	X12TransactionSetX12998     X12TransactionSet = "X12_998"
	X12TransactionSetX12999     X12TransactionSet = "X12_999"
	X12TransactionSetX12270X279 X12TransactionSet = "X12_270_X279"
	X12TransactionSetX12271X279 X12TransactionSet = "X12_271_X279"
	X12TransactionSetX12275X210 X12TransactionSet = "X12_275_X210"
	X12TransactionSetX12275X211 X12TransactionSet = "X12_275_X211"
	X12TransactionSetX12276X212 X12TransactionSet = "X12_276_X212"
	X12TransactionSetX12277X212 X12TransactionSet = "X12_277_X212"
	X12TransactionSetX12277X214 X12TransactionSet = "X12_277_X214"
	X12TransactionSetX12277X364 X12TransactionSet = "X12_277_X364"
	X12TransactionSetX12278X217 X12TransactionSet = "X12_278_X217"
	X12TransactionSetX12820X218 X12TransactionSet = "X12_820_X218"
	X12TransactionSetX12820X306 X12TransactionSet = "X12_820_X306"
	X12TransactionSetX12824X186 X12TransactionSet = "X12_824_X186"
	X12TransactionSetX12834X220 X12TransactionSet = "X12_834_X220"
	X12TransactionSetX12834X307 X12TransactionSet = "X12_834_X307"
	X12TransactionSetX12834X318 X12TransactionSet = "X12_834_X318"
	X12TransactionSetX12835X221 X12TransactionSet = "X12_835_X221"
	X12TransactionSetX12837X222 X12TransactionSet = "X12_837_X222"
	X12TransactionSetX12837X223 X12TransactionSet = "X12_837_X223"
	X12TransactionSetX12837X224 X12TransactionSet = "X12_837_X224"
	X12TransactionSetX12837X291 X12TransactionSet = "X12_837_X291"
	X12TransactionSetX12837X292 X12TransactionSet = "X12_837_X292"
	X12TransactionSetX12837X298 X12TransactionSet = "X12_837_X298"
	X12TransactionSetX12999X231 X12TransactionSet = "X12_999_X231"
)

Enum values for X12TransactionSet

func (X12TransactionSet) Values 

func (X12TransactionSet) Values() []X12TransactionSet

Values returns all known values for X12TransactionSet. Note that this can be expanded in the future, and so it is only as up to date as the client.

The ordering of this slice is not guaranteed to be stable across updates.

type X12ValidationOptions 

type X12ValidationOptions struct {

	// Specifies a list of validation rules to apply during EDI document processing.
	// These rules can include code list modifications, element length constraints, and
	// element requirement changes.
	ValidationRules []X12ValidationRule
	// contains filtered or unexported fields
}

Contains configuration options for X12 EDI validation. This structure allows you to specify custom validation rules that will be applied during EDI document processing, including element length constraints, code list modifications, and element requirement changes. These validation options provide flexibility to accommodate trading partner-specific requirements while maintaining EDI compliance. The validation rules are applied in addition to standard X12 validation to ensure documents meet both standard and custom requirements.

type X12ValidationRule 

type X12ValidationRule interface {
	// contains filtered or unexported methods
}

Represents a single validation rule that can be applied during X12 EDI processing. This is a union type that can contain one of several specific validation rule types: code list validation rules for modifying allowed element codes, element length validation rules for enforcing custom length constraints, or element requirement validation rules for changing mandatory/optional status. Each validation rule targets specific aspects of EDI document validation to ensure compliance with trading partner requirements and business rules.

The following types satisfy this interface: 

X12ValidationRuleMemberCodeListValidationRule
X12ValidationRuleMemberElementLengthValidationRule
X12ValidationRuleMemberElementRequirementValidationRule
Example (OutputUsage) 
package main

import (
	"fmt"
	"github.com/aws/aws-sdk-go-v2/service/b2bi/types"
)

func main() {
	var union types.X12ValidationRule
	// type switches can be used to check the union value
	switch v := union.(type) {
	case *types.X12ValidationRuleMemberCodeListValidationRule:
		_ = v.Value // Value is types.X12CodeListValidationRule

	case *types.X12ValidationRuleMemberElementLengthValidationRule:
		_ = v.Value // Value is types.X12ElementLengthValidationRule

	case *types.X12ValidationRuleMemberElementRequirementValidationRule:
		_ = v.Value // Value is types.X12ElementRequirementValidationRule

	case *types.UnknownUnionMember:
		fmt.Println("unknown tag:", v.Tag)

	default:
		fmt.Println("union is nil or unknown type")

	}
}

type X12ValidationRuleMemberCodeListValidationRule 

type X12ValidationRuleMemberCodeListValidationRule struct {
	Value X12CodeListValidationRule
	// contains filtered or unexported fields
}

Specifies a code list validation rule that modifies the allowed code values for a specific X12 element. This rule enables you to customize which codes are considered valid for an element, allowing for trading partner-specific code requirements.

type X12ValidationRuleMemberElementLengthValidationRule 

type X12ValidationRuleMemberElementLengthValidationRule struct {
	Value X12ElementLengthValidationRule
	// contains filtered or unexported fields
}

Specifies an element length validation rule that defines custom length constraints for a specific X12 element. This rule allows you to enforce minimum and maximum length requirements that may differ from the standard X12 specification.

type X12ValidationRuleMemberElementRequirementValidationRule 

type X12ValidationRuleMemberElementRequirementValidationRule struct {
	Value X12ElementRequirementValidationRule
	// contains filtered or unexported fields
}

Specifies an element requirement validation rule that modifies whether a specific X12 element is required or optional within a segment. This rule provides flexibility to accommodate different trading partner requirements for element presence.

type X12Version 

type X12Version string
const (
	X12VersionVersion4010      X12Version = "VERSION_4010"
	X12VersionVersion4030      X12Version = "VERSION_4030"
	X12VersionVersion4050      X12Version = "VERSION_4050"
	X12VersionVersion4060      X12Version = "VERSION_4060"
	X12VersionVersion5010      X12Version = "VERSION_5010"
	X12VersionVersion5010Hipaa X12Version = "VERSION_5010_HIPAA"
)

Enum values for X12Version

func (X12Version) Values 

func (X12Version) Values() []X12Version

Values returns all known values for X12Version. Note that this can be expanded in the future, and so it is only as up to date as the client.

The ordering of this slice is not guaranteed to be stable across updates.

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.