All Classes and Interfaces

Class
Description
Emits a validation event if shapes or member names do not use strict camelCasing (e.g., XmlRequest is preferred over XMLRequest).
AbbreviationName configuration settings.
 
Helper class for generating code.
Provides a default diff evaluator implementation with utility methods for emitting events of different severities.
Abstract builder used to create Shapes.
Base implementation of traits.
Basic provider implementation that returns the name of the provided trait.
Provides the shared logic that all trait builders need.
Abstract Validator class that has helpful methods for emitting events.
Represents an acceptor in a waiter's state machine.
The transition state of a waiter.
 
 
Contains information about a resource an IAM action can be authorized against.
 
Contains information about the resources an IAM action can be authorized against.
 
 
 
A meta-validator that emits a NOTE when an operation resource is added to a service or resource entity.
Creates a NOTE event when metadata is added.
Emits a warning when an error is added to an operation.
Validates that no members are newly created with the required trait (but no default trait) in existing structures.
Emits a warning when an error is added to a service.
Creates a NOTE event when a shape is added.
Creates a NOTE event when a trait definition is added.
And expression where both sides must return truthy values.
Trait implementation for traits that are an empty object.
Trait provider that expects a boolean value of true.
Styles text using ANSI color codes.
The "any" type, which matches all other types.
API Gateway OpenAPI configuration.
The type of API Gateway service to generate.
 
 
An API Gateway mapper that only applies when the type of API being converted matches the types of APIs handled by the mapper.
 
 
Indicates that a compliance test case is only to be implemented by "client" or "server" implementations.
Applies transforms of other projections.
apply configuration.
A command line argument receiver.
Command line arguments list to evaluate.
Resolves and indexes the ARN templates for each resource in a service.
Indicates that a string shape contains an ARN.
Builder for ArnReferenceTrait.
 
Ensures that all arn traits for a service are valid and that their templates only reference valid resource identifiers.
Configures the ARN template of a resource shape, relative to the service to which a resource is bound.
Builder for ArnTrait.
 
Represents an array of nodes.
Builder used to efficiently create an ArrayNode.
The "array" type, which contains entries of a member type.
An array of values of the same type.
Class that defines the acceptable values that can be used in ShapeLink objects.
 
Selector attribute values are the data model of selectors.
This trait is attached to another trait to define an auth scheme.
 
 
Represents an API Gateway authorizer.
Builder used to create an AuthorizerDefinition.
Computes the effective authorizers of each resource and operation in a service.
Defines a map of API Gateway x-amazon-apigateway-authorizer values that correspond to Smithy authorization definitions.
Builds an AuthorizersTrait.
 
Validates if authorizers traits are well-defined.
Attaches an API Gateway authorizer to a service, resource, or operation.
 
Validates an authentication scheme after passing a predicate check.
Specifies the auth schemes supported by default for operations bound to a service.
 
All @auth trait values referenced from an operation must refer to authentication traits applied to service shapes that enclose the operation.
An AWS ARN.
A builder used to create an AwsArn class.
AWS-specific built-in parameters for EndpointRules.
An RPC-based protocol that sends JSON payloads.
 
 
An RPC-based protocol that sends JSON payloads.
 
 
An AWS rule-set function for mapping a region string to a partition.
A FunctionDefinition for the AwsPartition function.
Represents a configurable AWS protocol trait.
Builder for creating a AwsProtocolTrait.
 
 
Provides the value in the "Code" distinguishing field and HTTP response code for an operation error.
Builder used to create an AwsQueryErrorTrait.
 
An RPC-based protocol that sends query string requests and XML responses.
 
Converts the aws.protocols#restJson1 protocol to OpenAPI.
AWS-specific extensions to smithy-rules-engine.
Provides methods for interfacing with Java representations of the different kinds of vendor params shapes used in smoke tests for AWS services.
Validate special case endpoints from endpoint traits that are applied on a service.
Index of AWS tagging trait information in a service closure and convenient access to tag operations by name in service closures.
Adds AWS signature version in a way that"s compatible with AWS API Gateway.
Concrete vendor params to apply to AWS services by default.
Base vendor params for all AWS services.
Represents a integer shape.
Builder used to create a BigDecimalShape.
Represents a integer shape.
Builder used to create a BigIntegerShape.
Abstract class representing expressions that have a left and right side.
Represents a blob shape.
Builder used to create a BlobShape.
Represents a two argument function that compares two expression for boolean equality.
A FunctionDefinition for the BooleanEquals function.
A boolean literal value, containing true or false.
Represents a boolean node.
Represents a boolean shape.
Builder used to create a BooleanShape.
The "boolean" type.
A boolean value of true or false.
Computes all of the parent shapes of resources and operations from the bottom-up.
Deprecated.
Deprecated.
Use NullableIndex instead.
 
Manages the creation, copying, and reuse of values created by builders.
POJO to represents a smithy-build-info.json file.
Writes a build info file for each projection.
This builder can be used to build up a Smithy CLI command to run `smithy build`.
Interface used to query a classpath for the given projection sources tags.
Finds JARs by opening each JAR in the classpath and looking for "Smithy-Tags" in the META-INF/MANIFEST.MF file.
Result class used to build source and projection JARs.
Built-in parameters for EndpointRules.
Represents a byte shape.
Builder used to create a ByteShape.
 
 
Emits a validation event if shapes at a specific location do not match the desired camel casing format.
CamelCase configuration settings.
 
 
A persisted token captured from an IdlTokenizer.
 
Provides support for camelCase, snake_case, and other kinds of case conversions.
Indicates that the CloudFormation property generated from this member is an additional identifier for the resource.
 
"cloudformation" smithy-build plugin configuration settings.
 
Indicates that the CloudFormation property generated from this member has a default value for this resource.
 
 
Indicates that structure member should not be included in generated CloudFormation resource definitions.
 
Provides a plugin infrastructure to hook into the Smithy CloudFormation Resource Schema generation process and map over the result.
Indicates an explicit CloudFormation mutability of the structure member when part of a CloudFormation resource.
 
Validates that members marked as having write-only mutability are not also marked as additional identifiers for their CloudFormation resource.
 
 
Contains extracted resource information.
 
Index of resources to their CloudFormation identifiers and properties.
Mutability options derived through lifecycle operations or traits.
Contains extracted resource property information.
 
Validates that derived CloudFormation properties all have the same target.
Indicates that a Smithy resource is a CloudFormation resource.
 
 
 
Emits a NOTE when a new enum value is appended, emits an ERROR when an enum value is removed, emits an ERROR when an enum name changes, and emits an ERROR when a new enum value is inserted before the end of the list of existing values.
Detects when the Length trait is made more restrictive by either raising the min or lowering the max.
Creates a DANGER event when a structure or union member is added anywhere other than the end of the previous definition or the member order is changed.
Checks for changes in the shapes targeted by a member.
Represents a change in metadata.
Creates a WARNING event when metadata is changed.
Validates that only backward compatible changes are made to structure member nullability to ensure that if something was previously nullable to clients then it continue to be nullable and vice versa.
Emits an ERROR when the input shape of an operation is changed to another shape.
Emits an ERROR when the output shape of an operation is changed to another shape.
Detects when the Range trait is made more restrictive by either raising the min or lowering the max.
Creates an ERROR event when the identifiers of a resource changes.
Represents a changed shape.
Creates an ERROR event when the type of a shape changes.
Options that can be enabled when changing shape types.
changeStringEnumsToEnumShapes is used to change string shapes bearing the enum trait into enum shapes.
changeStringEnumsToEnumShapes configuration settings.
changeType is used to change the type of one or more shapes.
flattenNamespaces configuration settings.
Checks for greedy labels and fails/warns depending on configuration.
Checks for prefix headers in the input or output of an operation, and handles the settings for throwing an exception or warning if they're found.
Removes operation bindings from resources and services when operations are removed, and removes resource bindings from services and resources when resources are removed.
Removes the endpoint discovery trait from a service if the referenced operation or error are removed.
 
Removes references to removed structures from operation input, output, and errors.
Removes references to resources that are removed from ReferencesTraits.
Removes "rename" entries from service shapes when a shape is removed.
Cleans up structure, union, enum, and intEnum shapes after shapes are removed.
Removes traits from AuthDefinitionTrait and ProtocolDefinitionTrait traits that refer to removed shapes.
This class provides a basic CLI abstraction.
A service client context parameter definition.
 
Indicates that the named rule-set parameters that should be configurable on the service client using the specified smithy types.
 
 
Indicates that the target operation should use the SDK's endpoint discovery logic.
 
Indicates members of the operation input which should be use to discover endpoints.
 
 
 
Configures endpoint discovery for the targeted service.
 
 
Indicates that non-authoritative code generators should treat a member as optional even if it's required or default.
 
Throw this exception to cause the CLI to exit with a message and code.
Handles text output of the CLI.
A context object that can be used during code generation and is used by SmithyIntegration.
Performs directed code generation of a DirectedCodegen.
Thrown when an error occurs during code generation.
Deprecated.
prefer SymbolWriter.
Deprecated.
Deprecated.
A CodeSection interceptor for a specific type of CodeSection.
A code section interceptor that adds text after the intercepted section.
A code section interceptor that adds text before the intercepted section.
Interface used for strongly typed AbstractCodeWriter section values.
Deprecated.
prefer SimpleCodeWriter or a custom subclass of AbstractCodeWriter.
Provides debug information about the current state of a CodeWriter.
Configures an Amazon Cognito User Pools auth scheme.
 
Abstract class representing Set and List shapes.
Builder used to create a List or Set shape.
An Appendable that supports color provided by a ColorFormatter.
Styles text using color codes.
Standardizes on colors across commands.
Represents a CLI command.
Environment settings for the command.
Compares the left and right expression using a comparator, resulting in a boolean value.
A comparator in a comparison expression.
Abstract class used for most OpenAPI model components.
 
 
 
A condition is call to a rule-set function that used to determine whether a rule should be executed.
A builder used to create a Condition class.
 
 
Provides an index of condition keys for a service, including any condition keys inferred from resource identifiers.
Applies condition keys to an operation or resource.
 
 
Ensures that condition keys referenced by operations bound within the closure of a service are defined either explicitly using the defineConditionKeys trait or through an inferred resource identifier condition key.
 
 
An abstract class used to more easily implement a Smithy build projection transformer that expects configuration input in a specific type, T.
An abstract class used to more easily implement a Smithy build plugin that expects configuration input in a specific type, T.
Thrown when two shapes generate the same JSON schema pointer.
Smithy to CloudFormation conversion context object.
Context<T extends Trait>
Smithy to OpenAPI conversion context object.
Resolves an indexes the context parameters in the model.
Binds a Structure member shape to a rule-set parameter.
 
 
Directive that contains a CodegenContext.
This validation event formatter outputs a validation event that points to the source code line that triggered the event.
 
 
Registers the core Smithy2CloudFormation functionality.
Registers the core Smithy2OpenApi functionality.
Core extensions to smithy-rules-engine.
Adds support for the API Gateway x-amazon-apigateway-cors extension for API Gateway HTTP APIs using values from the Smithy cors trait.
 
 
 
Analyzer for determining coverage of a rule-set.
A container for a specific condition's coverage result.
Directive used to create a CodegenContext.
Directive used to create a SymbolProvider.
Gets the current node.
Directive used to perform post-processing code generation.
 
 
 
 
Provides a default value for a shape or member.
 
 
Finds operations that are meant to partially update a resource, but that use members with default values in their input shapes, making it impossible to know if the member was provided explicitly or defaulted.
Defines condition keys used in a service.
 
 
Resolves Maven dependencies for the Smithy CLI.
Responsible for creating a DependencyResolver for the CLI, optionally based on configuration.
Exception encountered while attempting to resolve dependencies.
A container for all known dependencies of a generator.
Container for information on a deprecated parameter.
Marks a shape as deprecated.
Builder used to create a DeprecatedTrait.
 
Emits a validation event if a model contains shapes that are bound to deprecated traits.
Queryable container for detected structural differences between two models.
Interface used to evaluate two models and their normalized differences and return ValidationEvents that are relative to the new model.
Provides a directed code generation abstraction to make it easier to implement a Smithy code generator for a single service that leverages other abstractions in smithy-codegen-core, including SmithyIntegration, SymbolProvider, CodegenContext, SymbolWriter, and WriterDelegator.
Directive classes contain all of the context needed in order to perform the tasks defined in a DirectedCodegen implementation.
Disables the automatic inference of condition keys of a resource.
 
Adds documentation to a model.
 
Deprecated.
prefer DocWriter.
Represents a document shape.
Builder used to create a DocumentShape.
Deprecated.
Represents a double shape.
Builder used to create a DoubleShape.
An endpoints modifier trait that indicates a service has only dual stack endpoints, does not support IPV4 only endpoints, and should not have the useDualStackEndpoint endpoint parameter.
 
A general-purpose trait used to represent traits that are defined in the model and have no concrete implementation.
Indicates the serialized name of a structure member when that structure is serialized for the input of an EC2 operation.
 
An RPC-based protocol that sends query string requests and XML responses, customized for Amazon EC2.
 
Queries a model for effective traits bound to shapes and members.
Builds a reusable EffectiveTraitQuery.
Emits a validation event for each shape that matches a selector.
EmitEachSelector configuration settings.
 
Emits a validation event if no shapes match the given selector.
EmitNoneSelector configuration settings.
 
The "empty" type.
An empty value.
 
 
An EndpointType as returned by EndpointRules.
Builder for Endpoint.
Utilities for constructing and validating AWS-specific authentication components for rule-sets.
Provides access to endpoint components loaded through EndpointRuleSetExtensions.
Locates the endpoint modifier traits applied to services.
A meta-trait that marks a trait as an endpoint modifier.
 
The pattern type to use for the partitional services.
A rule-set rule that specifies a resolved endpoint.
A set of EndpointRules.
A builder used to create a EndpointRuleSet class.
An interface to provide components to endpoints rule-sets.
Defines an endpoint rule-set used to resolve the client's transport endpoint.
 
 
Describes an endpoint rule-set test case.
 
An endpoint test case expectation.
 
A description of a service operation and input used to verify an endpoint rule-set test case.
 
Describes test cases for validating an endpoint rule-set.
 
 
Validates the EndpointTestsTrait.
Defines custom endpoint bindings of an operation.
 
 
The "endpoint" type, representing a valid client endpoint.
An endpoint value, containing a URL as well as headers that MUST be sent.
A builder used to create an EndpointValue class.
Abstract class representing service and resource shapes.
Builder used to create a Service or Resource shape.
An enum definition for the enum trait.
Builds a EnumDefinition.
 
 
Emits an error validation event if an enum member's enumValue trait has the wrong type, if there are any duplicate values in a single enum, if the enum's default value is set using the enumValue trait, or if an intEnum member lacks an enumValue trait.
Deprecated.
Builder used to create the enum trait.
 
Ensures that enum traits are valid.
Sets the value for an enum member.
 
 
Environment variables used by the Smithy CLI.
 
A rule-set rule that is used to indicate an error in evaluation.
Indicates that a structure can be used as an error.
 
Marks a structure member of an event as an event header.
 
Marks a structure member of an event as the event payload.
 
Ensures that when an event structure contains an eventPayload member, that all other members are bound to headers.
Validates that the aws.api#service/eventSource property matches aws.api#service/arnNamespace + ".amazonaws.com" and does not use incorrect formats.
Index of operation shapes to event stream information.
Contains extracted event stream information.
 
 
Defines examples for an operation.
Builds an examples trait.
 
 
A specific example.
Builder used to create ExamplesTrait.Examples.
 
Validates that examples traits are valid for their operations.
excludeMetadata removes metadata entries when a metadata key matches keys.
excludeMetadata configuration settings.
excludeShapesBySelector excludes the shapes matching the given selector.
excludeShapesBySelector configuration.
excludeShapesByTag removes shapes if they are tagged with one or more of the given arguments.
excludeShapesByTag configuration.
Removes shapes from the model if they are marked with a specific trait.
 
excludeTags removes tags from shapes and trait definitions that match any of the provided tags.
excludeTags configuration.
excludeTraits removes trait definitions and traits from shapes when a trait name matches any of the values given in traits.
excludeTraits configuration settings.
excludeTraitsByTag removes traits and trait definitions from a model if the trait definition contains any of the provided tags.
excludeTraitsByTag configuration settings.
Validates traits that can only be applied to a single structure member.
Defines the expected result of the service call for a smoke test case.
Thrown by Node methods that expect a node to be of a particular type or to have a particular member.
An endpoint test-case expectation.
 
A dynamically computed expression.
Represents a problem detected by static analysis.
The severity of the problem.
Serializes the JMESPath expression AST back to a JMESPath expression.
Contains a reference to an expression that can be run zero or more times by a function.
Visits each type of AST node.
Expression visitor pattern.
 
 
 
Provides named links to external documentation.
Builder used to create the external documentation trait.
 
Defines the expected failure of a service call for a smoke test case.
Gets a field by name from an object.
A resolver that loads and caches resolved artifacts to a JSON file if the cache is fresh and resolved artifacts haven't been updated after a given reference point in time.
Creates and tracks the files generated by a SmithyBuildPlugin.
Removes Smithy CLI dependencies that conflict with the JARs used by the CLI.
A projection that filters values using a comparison.
Filters suppressions found in metadata and SuppressTrait traits.
filterSuppressions configuration settings.
Flattens the wrapped expression into an array.
flattenNamespaces updates a model by flattening the namespaces of shapes connected to a service into a single, target namespace.
flattenNamespaces configuration settings.
Represents a integer shape.
Builder used to create a FloatShape.
Formats valid Smithy IDL models.
A value that can be traced back to a SourceLocation.
Utilities for working with functions, predicates, etc.
An abstract definition of a rule-engine function.
Executes a function by name using a list of argument expressions.
Parsed but not validated function contents containing the `fn` name and `argv`.
A builder used to create a FunctionNode class.
Directive used to generate an enum shape or enum string shape.
Represents the type of enum to generate.
Directive used to generate an error.
Directive used to generate an intEnum.
Directive used to generate an operation.
Directive used to generate a resource.
Directive used to generate a service.
Directive used to generate a structure.
Directive used to generate a union.
A rule-set expression for indexing a record/object or array.
A FunctionDefinition for the GetAttr function.
 
 
 
Data class representing a CloudFormation Resource Schema's handler definition.
 
Generates the resource's handler permissions list based on the lifecycle operation used and any permissions listed in the aws.iam#requiredActions trait.
Generates and prints structured help output.
Binds an input member to a label in the hostPrefix of an endpoint trait on an operation.
 
Validates that hostLabel traits are applied correctly for operation inputs.
Uses an HTTP header named X-Api-Key that contains an API key.
An HTTP-specific authentication scheme that sends an arbitrary API key in a header or query string parameter.
 
 
 
Validates that if an HttpApiKeyAuth trait's scheme field is present then the 'in' field must specify "header".
An auth scheme trait uses HTTP basic auth.
 
Applies Basic HTTP auth.
An auth scheme trait uses HTTP bearer auth.
 
Uses the Bearer scheme of the Authentication header.
Defines an HTTP message member binding.
HTTP binding types.
Computes and indexes the explicit and implicit HTTP bindings of a model.
Validates that if any operation in a service uses the http trait, then all operations use them.
Emits warnings when a structure member has an HTTP binding trait that will be ignored in some contexts to which it is bound.
Indicates that an operation requires a checksum in its HTTP request.
 
Indicates that an operation supports checksum validation.
 
 
Validates the HttpChecksum trait.
An auth scheme trait uses HTTP digest auth.
 
Applies Digest HTTP auth.
Defines a custom HTTP status code for error structures.
 
Binds a member to an HTTP header.
 
Validates that httpHeader traits are case-insensitively unique.
Binds a member to a URI label of an input of an operation using the member name.
 
Validates that httpLabel traits are applied correctly for operation inputs.
Defines a request to be used by an HttpMalformedRequest test case.
Builder used to create a HttpRequestTestsTrait.
Defines a test case for malformed HTTP requests.
Builder used to create a HttpMalformedRequestTestCase.
Defines protocol tests for malformed HTTP request handling.
 
Ensures that parameters attached to @httpMalformedRequestTest cases are well-formed.
Defines the response expected by an HttpMalformedRequest test case.
Builder used to create a HttpMalformedResponseBodyDefinition.
Defines the response expected by an HttpMalformedRequest test case.
Builder used to create a HttpMalformedResponseDefinition.
 
Validates that `http` traits applied to operation shapes use the most semantically appropriate HTTP method according to RFC 7231.
Binds a single structure member to the payload of an HTTP request.
 
Validates that if a payload trait is present then all members of the input of an operation are bound to part of the message.
Binds a map structure member to prefixed HTTP headers.
 
Validates that httpHeader traits do not case-insensitively start with an httpPrefixHeader on the same structure.
Binds a map structure member to the HTTP query string.
 
When the `httpQueryParams` trait is used, this validator emits a NOTE when another member of the container shape applies the `httpQuery` trait which may result in a conflict within the query string.
Binds a member to an HTTP query string.
 
Validates that httpQuery trait bindings are case-sensitively unique.
Defines a test case for an HTTP request.
Builder used to create a HttpRequestTestsTrait.
Ensures that input parameters of protocol request test cases are valid for the attached operation.
Defines HTTP request protocol tests.
 
Ensures that HTTP response codes are appropriate for operations and errors.
Indicates that the structure member represents the HTTP response status code.
 
Defines a test case for an HTTP response.
Builder used to create a HttpResponseTestCase.
Validates that protocol tests on errors use the correct params.
Validates that protocol tests on output use the correct params.
Defines HTTP request protocol tests.
 
Defines the HTTP request and response code bindings of an operation.
Builder used to create an Http trait.
 
Validates that no two URIs in a service conflict with each other.
 
Indicates properties of a Smithy operation as an IAM action.
 
 
 
Indicates properties of a Smithy resource in AWS IAM.
 
 
Ensures that any resource name defined in the IamResourceTrait is consistent with the resource name used in any ArnTrait definition applied to the resource.
Defines an operation input member that is used to prevent replayed requests.
 
Indicates that an operation is idempotent.
 
A name used to identify a component of a rule-set.
Index of operation shapes to the identifiers bound to the operation.
 
Represents a parsed token from the Smithy IDL.
Iterates over a Smithy IDL model as a series of tokens.
Indicates that a string value must contain a valid shape ID.
 
 
Contains the imports associated with a specific file.
Deprecated.
includeMetadata keeps only metadata keys specifically defined in the provided keys setting.
includeMetadata configuration settings.
includeNamespaces filters out shapes and trait definitions that are not part of one of the given namespaces.
includeNamespaces configuration.
includeServices filters out service shapes that are not included in the list of shape IDs contained in the services property.
includeServices configuration.
includeShapesBySelector includes the shapes matching the given selector.
includeShapesBySelector configuration.
includeShapesByTag removes shapes and trait definitions that are not tagged with at least one of the tags provided in the tags argument.
includeShapesByTag configuration.
includeTags removes tags from shapes and trait definitions that are not in the set of tags defined in the tags property.
includeTags configuration.
includeTraits removes trait definitions when a trait name does not match one of the provided traits shape IDs.
includeTraits configuration settings.
includeTraitsByTag removes trait definitions from a model if the definition does not contain at least one of the provided tags.
includeTraitsByTag configuration settings.
Gets a specific element by zero-based index.
 
 
Represents an error encountered when parsing a rule-set expression.
Validates that all operations define input and output structures that are marked with the input and output traits.
 
Specializes a structure as the input of a single operation.
 
An integer literal value, containing integer values greater than or equal to 0.
Represents an integer shape.
Builder used to create a IntegerShape.
The "integer" type.
An integer value.
An API Gateway integration response object.
API Gateway integration.
 
 
Computes the API Gateway integration for each operation, resource, and service shape in a model.
 
Builder used to create a IntegerShape.
Shapes marked with the internal trait are meant only for internal use and must not be exposed to customers.
 
Exception thrown for invalid patterns.
Exception thrown when a rule-set is invalid.
Exception thrown for invalid HTTP URI patterns.
Utilities for IO operations.
A rule-set function for determining whether a reference parameter is set.
A FunctionDefinition for the IsSet function.
A rule-engine function for checking whether a string is a valid DNS host label.
An AWS rule-set function for determining whether a given string can be promoted to an S3 virtual bucket host label.
Deprecated.
this class uses CodeWriter, which is deprecated.
Thrown when any JMESPath error occurs.
Represents a JMESPath AST node.
Provides a custom name to use when serializing a structure member name as a JSON object property.
 
 
JSON Schema configuration options.
Configures how Smithy map shapes are converted to JSON Schema.
Configures how Smithy union shapes are converted to JSON Schema.
Converts a Smithy model index to a JSON schema document.
 
Updates a schema builder before converting a shape to a schema.
Context for a JSON schema mapping.
Configures the schema version to use when converting Smithy shapes to JSON Schema.
Finds string set in a Node object string value and replaces them with a corresponding Node.
A marker interface used to indicate that a class contains an index of computed knowledge about a Model.
Constrains a shape to minimum and maximum number of elements or size.
Builder used to create a LongTrait.
 
 
A function which is constructed from a FunctionDefinition.
Writes ValidationEvent objects as a single line string.
 
 
Contains the result of JmespathExpression.lint().
Represents a list shape.
Builder used to create a ListShape.
Immutable List utilities to polyfill Java 9+ features.
Literals allow rules and properties to define arbitrarily nested JSON structures (e.g.for properties)
Represents a literal value.
Literal visitor interface.
Represents a integer shape.
Builder used to create a LongShape.
A reserved words implementation that maps known words to other words.
Builder to create a new MappedReservedWords instance.
Represents a map shape.
Builder used to create a ListShape.
Immutable Map utilities to polyfill Java 9+ features.
Determines if an acceptor matches the current state of a resource.
Matches if an operation returns an error, and the error matches the expected error type.
 
 
When set to true, matches when a call returns a success response.
Represents an union value.
Visits the variants of the Matcher union type.
 
 
Resolves Maven dependencies for the Smithy CLI using Maven resolvers.
 
 
Implements a simple media type parser based on the Content-Type grammar defined in RFC 7231.
 
 
Documents the media type of a blob shape.
 
 
Represents a member that targets another shape by ID.
Builder used to create a MemberShape.
Validates that the clientOptional trait is applied based on the rules defined in the validator.
MissingClientOptionalTrait configuration settings.
 
Checks if an operation should be paginated but is not.
 
 
Validates that shapes and members that possibly contain sensitive data are marked with the sensitive trait.
MissingSensitiveTrait configuration.
 
 
Builder used to create a MixinTrait.
 
API Gateway mock integration.
 
 
A FileManifest that doesn't actually store files on disk.
The way in which files are stored.
A Smithy model that contains shapes, traits, metadata, and various computed information used to interpret the model.
Builder used to create a Model.
Assembles and validates a Model from documents, files, shapes, and other sources.
Creates a ValidationEventDecorator that applies custom suppressions, custom severity overrides, suppressions parsed from model metadata, and severity overrides parsed from model metadata.
Computes the difference between two models and any problems that might occur due to those differences.
Builder used to construct a diff of two Smithy models.
The result of comparing two Smithy models.
Discovers Smithy models by finding all META-INF/smithy/manifest files on the class path and loading all of the newline separated relative model files referenced from the manifest.
Exception thrown when a model fails to be imported.
 
Writes the projected/filtered SmithyBuild model.
Serializes a Model to an ObjectNode.
Builder used to create ModelSerializer.
Thrown when the syntax of the IDL is invalid.
Class used to transform Models.
Plugin service used with ModelTransformer.
Exception thrown when a model transformation error occurs.
Finds breaking changes related to when a trait is added, removed, or updated.
 
 
Validates that no two MQTT topics conflict.
Validates that labels are correct for MQTT topics on subscribe and publish operations.
Creates an object using key-value pairs.
Selects one or more values into a created array.
Provides the neighbor relationships for a given shape.
Provides a cache of precomputed neighbors for models.
Indicates that the contents of a structure member contain the top-level properties of the associated resource.
 
An auth scheme trait for smithy.api#noAuth which indicates no authentication.
Base class of for all Smithy model nodes.
Non-numeric values for floats and doubles.
Exception encountered during deserialization.
 
Serializes and deserializes Smithy Node values to/from objects.
Specifies the behavior of the mapper when attempting to deserialize an unknown property.
JSON Pointer abstraction over Smithy Node values.
Exception encountered during serialization.
The set of possible node types.
Validates Node values provided for Shape definitions.
Features to use when validating.
Applies pluggable validation when validating Node values against the schema of a Shape (e.g., when validating that the values provided for a trait in the model are valid for the shape of the trait).
Validation context to pass to each NodeValidatorPlugin.
 
Node visitor interface.
Creates NodeVisitor that return a default value when necessary when visiting nodes.
Detects when a protocol indicates that it does not support inline documents, yet the protocol trait is attached to a service that uses inline documents.
Validates that all shape names and values do not contain non-inclusive terms.
NoninclusiveTermsValidator configuration.
 
Indicates that the put lifecycle operation of a resource can only be used to create a resource and cannot replace an existing resource.
 
 
A FunctionDefinition for the Not function.
Negates an expression based on if the wrapped expression is truthy.
Indicates that a top level input/output structure member is not associated with a resource property.
 
Generates a JSON report that contains a mapping of every structure member to whether the member is considered nullable in v1 and v2 implementations.
An index that checks if a member is nullable.
Defines the type of model consumer to assume when determining if a member should be considered nullable or always present.
Represents a null node.
Represents a number node.
Abstract class representing all numeric types.
Represents an object node.
Builder used to efficiently create an ObjectNode.
A projection of object values.
 
 
"openapi" smithy-build plugin configuration settings.
Specifies how to resolve multiple error responses with same error codes.
Specifies what to do when the httpPrefixHeaders trait is found in a model.
Converts a Smithy model to OpenAPI.
 
Adds JSON values into the generated OpenAPI model using a JSON Patch like "add" operation that also generated intermediate objects as needed.
Applies OpenAPI extensions to a Schema using configuration settings found in OpenApiConfig.
Substitutes JSON string values using the mapping defined in openapi.substitutions.
Provides a plugin infrastructure used to hook into the Smithy to OpenAPI conversion process and map over the result.
An OpenAPI protocol is used to convert a Smithy protocol into HTTP-specific bindings.
Represents an operation entry to add to an OpenApi.Builder.
 
OpenAPI versions supported by the converter.
Index of operation IDs to their resolved input, output, and error structures.
 
 
Represents an API operation.
Builder used to create a OperationShape.
Validates operation inputs, outputs, and the use of input and output traits.
Indicates that an operation / service supports unauthenticated access.
 
The "optional" type, a container for a type that may or may not be present.
Functions that make working with optionals easier.
Or expression that returns the expression that returns a truthy value.
Used to provide the original shape ID of a shape that is renamed in the semantic model.
Specializes a structure as the output of a single operation.
 
Index of operation shapes to paginated trait information.
Defines the pagination functionality of an operation.
Builds the paginated trait.
 
Validates paginated traits.
Resolved and valid pagination information about an operation in a service.
Generic immutable pair of values.
A rule-set parameter, representing a value usable in conditions and rules.
A builder used to create a Parameter class.
 
 
An iterable container for Parameters defined in a rule-set.
A builder used to create a Parameters class.
The types that parameters can be.
An aws rule-set function for parsing an AWS ARN into it's componenet parts.
A FunctionDefinition for the ParseArn function.
Utility methods that act on a SimpleParser and parse Smithy grammar productions.
A rule-set function to parse a URI from a string.
A FunctionDefinition for the ParseUrl function.
Describes an AWS partition, its regions, and the outputs to be provided from the rule-set aws.partition function.
A builder used to create a Partition class.
A special case that does not follow the services standard patterns or are located in a region other than the partition's default global region.
 
The outputs to be provided by the rule-set aws.partition function.
A builder used to create a Partition class.
A model for defining the set of partitions that are used by the rule-set aws.partition function.
A builder used to create a Partitions class.
A special case where endpoints for a partition that do not follow the standard patterns.
 
Defines a comparison to perform in a PathMatcher.
Finds the possible directed relationship paths from a starting shape to shapes connected to the starting shape that match a selector.
An immutable Relationship path from a starting shape to an end shape.
 
 
A Matcher implementation for inputPathList, outputPathList, and errorPathList.
Restricts string values to a specified regular expression.
 
Emits a validation event if a pattern trait is not anchored.
Determines if a service, resource, or operation are considered part of the data plane or control plane.
Context object used in plugin execution.
Builds a PluginContext.
Represents the prelude model available to every Smithy model.
Ensures that shapes in separate namespaces don't refer to shapes in other namespaces that are marked as private.
Indicates that a shape cannot be targeted outside of the namespace in which it was defined.
 
ProjectionConfig stored in a SmithyBuildConfig.
Iterates over each element in the array returned from the left expression, passes it to the right expression, and returns the aggregated results.
The result of applying a projection to a model.
Builds up a ProjectionResult.
Creates a model transformer by name.
Data class representing a CloudFormation Resource Schema's property.
 
Index of member shape to associated resource property information.
Determines the field/property/member name of a member in an object.
Configures how a structure member maps to a resource property.
 
 
A trait that is attached to other traits to define a Smithy protocol.
 
 
Ensures that the http payload trait is only bound to structures, unions, documents, blobs, or strings for AWS protocols.
Ensures that every entry in eventStreamHttp also appears in the http property of a protocol trait.
smithy.mqtt#publish trait.
 
Constrains a shape to minimum and maximum numeric range.
Builder used to create a RangeTrait.
 
Ensures that range traits are valid.
Indicates that an operation is read-only.
 
 
Builder used to create a RecommendedTrait.
 
A record literal value, containing a map of identifiers to other literals.
The "record" type, a map of identifiers to other types.
A record value, containing a map of identifiers to other values.
Ref<T extends ToNode>
 
A reference to a field.
Defines references to resources within a structure.
Builder use to create the references trait.
 
Reference to a resource.
Builder to create a ReferencesTrait.Reference.
Validates that references are correct.
Provides a facility for overriding a partition's regions.
 
A special case where endpoints for a region that do not follow the standard patterns.
 
Represent a direct relationship between two shapes.
Defines the directionality of a relationship.
Defines the relationship types between neighboring shapes.
Data class representing a CloudFormation Resource Schema's remote definition.
 
TODO: Implement evaluator to find removed authentication schemes.
A meta-validator that checks for the removal of an operation or resource binding from a service or resource.
Creates a DANGER event when metadata is removed.
Emits a warning when an error is removed from an operation.
Emits a warning when an error is removed from a service.
Creates an ERROR event when a non-private non-scalar shape is removed.
Creates an ERROR event when a trait definition is removed.
Removes empty key-value pairs in the "components" of a model if empty, and removes the "components" key-value pair of a model if it is empty.
Removes mixins from shapes when a mixin is removed from the model.
removeTraitShapes removes all trait definitions from a model, but leaves if the trait definition contains any of the provided tags.
removeTraitShapes configuration settings.
Removes traits from shapes when trait definitions are removed.
Removes unused components from the OpenAPI model.
removeUnusedShapes removes shapes from the model that are not connected to any service shape.
removeUnusedShapes configuration settings.
renameShapes updates a model by renaming shapes.
renameShapes configuration settings.
Validates that structure members and union member names do not repeat their shape name as prefixes of their member or tag names.
 
 
 
 
Indicates that an operation supports compressing requests from clients to services.
 
 
Validates the requestCompression trait.
 
 
 
 
Generates the resource's required properties list based on the required operation members that are part of the derived resource.
Indicates that a structure member is required.
 
Indicates that the streaming blob must be finite and has a known size.
 
Determines what is reserved and escapes reserved words.
Builds a ReservedWords implementation from explicit mappings and from line-delimited files that contain reserved words.
Emits validation events for a configuration of reserved words.
ReservedWords validator configuration.
 
A single reserved words configuration.
Decorates a SymbolProvider by passing values through context specific ReservedWords implementations.
Builder to build a ReservedWordSymbolProvider.
Uses to manually escape Symbols and member names.
An artifact resolved from a repository that provides the path on disk where the artifact was downloaded, and the coordinates of the artifact.
Computes all of the MQTT TopicBindings in a model.
Validates that resource references do not introduce circular hierarchies.
Validates that operations bound to resource shapes have identifier bindings for all the identifiers of the parent of the binding resource, that operations bound to a resource with the collection trait are bound using a collection binding, and operations bound with no collection trait are bound using an instance binding.
Binds an operation input member to a named identifier of the resource to which the operation is bound.
 
Validates that the resource identifiers of children of a resource contain all of the identifiers as their parents.
Validates that resource are applied appropriately to resources.
Validates that resource properties are correctly used in resource-bound operations.
Data class representing a CloudFormation Resource Schema.
 
Represents a resource shape.
Builder used to create a ResourceShape.
 
 
A RESTful protocol that sends JSON in structured payloads.
 
 
A RESTful protocol that sends XML in structured payloads.
 
 
Marks an error structure as retryable.
Builds a RetryableTrait trait.
 
The core functionality of a rule-set rule.
A builder used to create a Rule class.
A trait that indicates that a service has handwritten endpoint rules.
 
An exception that can be thrown when a rule-set is invalid.
 
A runtime implementation of a rule-set evaluation engine.
Builder which also tracks sourceLocation of inputs.
Validator which verifies an endpoint with an authSchemes property conforms to a strict schema.
Validator that AWS built-ins used in RuleSet parameters are supported.
Validates that the built-in's specified on parameters are supported.
Validator for rule-set parameters.
Validator to ensure that all parameters have documentation.
Validator to ensure that test cases for rule-sets pass type checking evaluation.
Validate that URIs start with a scheme.
Visitor for the right-hand side of rules (tree, error, endpoint).
Runs a process-based plugin.
 
 
 
 
Vendor params for S3.
Defines a single JSON schema.
Abstract class used to build Schema components.
Represents a JSON Schema document.
Builds a JSON Schema document.
Scope is a stack for tracking facts for named values of the given type.
Validates that SDK service IDs are correct and do not match any prohibited patterns.
 
 
Converts a Smithy authentication scheme to an OpenAPI security scheme and applies security requirements to operations.
Matches a set of shapes using a selector expression.
Deprecated.
This class is no longer necessary.
Represents a selector match found in the model.
Starting environment context object used when evaluating a selector.
Exception thrown when a selector evaluation is invalid.
Exception thrown when a selector expression is invalid.
Indicates that the data stored in the shape or member is sensitive and should be handled with care.
 
 
 
Validates the @authDefinition traits applied to service shapes.
An index that resolves service protocols and auth schemes.
Creates an ERROR event when a shape is renamed that was already part of the service, when a rename changes for a shape, or when a rename is removed for a shape.
 
 
Represents a service shape.
Builder used to create a ServiceShape.
Validates service satisfies AWS tagging requirements.
Registers a service as an AWS service.
Builder for ServiceTrait.
 
Validates that service closures do not contain duplicate case-insensitive shape names.
Deprecated.
Builder used to create a SetShape.
Immutable Set utilities to polyfill Java 9+ features.
 
Severity level of a validation exception.
Changes the severity of a validation event.
A Shape defines a model component.
ShapeDirective<T extends Shape,C extends CodegenContext<S,?,?>,S>
Directive used to generate a specific shape.
Shapes order for code generation.
Immutable identifier for each shape in a model.
Ensures that no two shapes in the model have the same case-insensitive shape ID.
Represents a shape ID syntax error.
Class that defines a link between the Smithy Shape and the artifact that it produced.
 
Ensures that list, set, and map shapes are not directly recursive, meaning that if they do have a recursive reference to themselves, one or more references that form the recursive path travels through a structure or union shape.
An enumeration of the different types in a model.
 
Shape visitor pattern.
Creates ShapeVisitor that only requires implementation of all data shape branches, but does not support service shapes.
Creates ShapeVisitor that return a value when necessary when visiting shapes.
Represents a short shape.
Builder used to create a ShortShape.
Validates that shapes that have names that appear to be time values are actually modeled with a timestamp shape.
 
 
Adds AWS Signature Version 4 Asymmetric authentication to a service or operation.
 
 
Adds AWS signature version 4 authentication to a service or operation.
 
 
Validates AWS Service, SigV4, and SigV4A traits.
Helper class for generating code.
A simple expression parser that can be extended to implement parsers for small domain-specific languages.
Abstract class representing all simple type shapes.
Defines when a shape or member was added to the model.
 
Validates that an operation is only bound to once in an entire service closure.
Validates that a resource is only bound to once in an entire service closure.
Represents a slice expression, containing an optional zero-based start offset, zero-based stop offset, and step.
 
An extension mechanism used to influence how CloudFormation resource schemas are generated from Smithy models.
Converts Smithy to an OpenAPI model and saves it as a JSON file.
An extension mechanism used to influence how Smithy models are converted to OpenAPI models.
Base implementation of a Smithy annotation processor.
Runs the projections and plugins found in a SmithyBuildConfig and writes the artifacts to a FileManifest.
Filter configuration that contains a list of named projections that are used to apply filters to a model.
Builder used to create a SmithyBuildConfig.
A mutable object that can be used to create an immutable object of type T.
Base exception thrown for any error that occurs while building.
Plugin extension class for SmithyBuild.
Encapsulates the result of running SmithyBuild.
Creates a SmithyBuildResult.
Entry point of the Smithy CLI.
 
Annotation used to indicate that a package or class was generated and should not be edited directly.
Defines how shapes, traits, and metadata are sorted when serializing a model with SmithyIdlModelSerializer.
Serializes a Model into a set of Smithy IDL files.
Builder used to create SmithyIdlModelSerializer.
This interface provides the base concept of an "Integration" to Smithy code generators.
Annotation used to indicate that an API is considered internal to Smithy and subject to change.
 
Represents a contained pattern.
Builder used to create a SmithyPattern.
Segment within a SmithyPattern.
 
Runs a single test case by loading a model and ensuring the resulting events match the validation events stored in a newline separated file.
Thrown when errors are encountered while unwrapping a test case.
Output of validating a model against a test case.
Runs test cases against a directory of models and error files.
Thrown when errors are encountered in the test runner.
Value result of executing the test suite.
Annotation used to indicate that an API is considered unstable and subject to change.
Defines a single smoke test case.
 
Validates the following: vendorParamsShape is a valid shape. vendorParams is compatible with vendorParamsShape. input is valid for the operation under test.
Defines a set of test cases to send to a live service to ensure that a client can connect to the service and get the right kind of response.
 
Loads lines of text from source location files to display in things like error messages.
A pair of line numbers to the contents of lines.
An exception that can be traced back to a SourceLocation.
Represents the source location of a model component.
Thrown when sources conflict in the source plugin.
Copies model sources into the sources plugin.
Indicates that a list or map is sparse, meaning they may contain nulls.
 
smithy.openapi#specificationExtension - Indicates a trait shape should be converted into an OpenAPI specification extension.
 
Validates that operation shape names start with standard verbs.
StandardOperationVerb configuration settings.
 
Options available to all commands.
An endpoints modifier trait that indicates that a service is partitional and a single endpoint should resolve per partition.
 
 
An endpoints modifier trait that indicates that a service's endpoints should be resolved using the standard AWS regional patterns.
 
 
An operation static context parameter definition.
 
Binds static values to rule-set parameters for the targeted operation.
 
 
Validates StaticContextParamsTrait traits.
Indicates that the data stored in the shape is very large and should not be stored in memory, or that the size of the data stored in the shape is unknown at the start of a request.
 
Validates the streaming trait.
A rule-set function for comparing strings for equality.
A FunctionDefinition for the StringEquals function.
Contains abstract functionality to build traits that contain a list of strings.
Abstract builder to build a StringList trait.
Trait provider that expects a list of string values.
Factory method to create a StringList provider.
A string literal value, containing a template.
Represents a string node.
Represents a string shape.
Builder used to create a StringShape.
This is a simple, not thread-safe, caching string table that converts CharSequence to String objects.
Abstract trait class for traits that contain only a string value.
Trait provider that expects a string value.
The "string" type.
Operations on String that are null safe.
A string value.
Structure shape that maps shape names to members.
Builder used to create a StructureShape.
Deprecated.
 
Colors and styles for use with AnsiColorFormatter or CliPrinter.
 
 
Visits the left expression and passes its result to the right expression.
smithy.mqtt#subscribe trait.
 
A rule-set function for getting the substring of a string value.
A FunctionDefinition for the Substring function.
 
 
 
Suppresses ValidationEvents emitted from Validators.
 
 
 
A "symbol" is created by a SymbolProvider, and represents the qualified name of a type in a target programming language.
Builds a Symbol.
A holder for Symbol objects.
Represents a dependency that is introduced by a Symbol.
Builds a SymbolDependency.
A container for SymbolDependency objects.
Provides Symbol objects for shapes.
Represents a reference from a Symbol to another Symbol.
Builds a SymbolReference.
Options used to control the context of when the symbol reference is needed.
Top-level interface for all SymbolReference options.
A SymbolWriter is a specialized AbstractCodeWriter that makes it easier to implement code generation that utilizes Symbols and SymbolDependency values.
Deprecated.
Factory used to create a SymbolWriter.
A class that is coercible into Conditions and Expressions for use in composing rule-sets in code.
A synthetic copy of the EnumTrait for use in the EnumShape.
 
Validates service has at least one taggable resource.
Trait annotating a service shape as having taggable resources.
 
 
Structure representing the configuration of resource specific tagging APIs.
Validates that service satisfies the AWS tagging requirements.
Marks a resource shape as taggable for further model validation.
 
 
A type that contains tags.
Contains extracted resource tagging information.
 
 
 
Validates expected tagging property name used for a taggable resource to encourage consistency.
Validates tagging property used for a taggable resource to encourage consistency.
Applies tags to a shape.
 
 
Validates that neighbors target resolvable shapes of the correct type.
Template represents a "Template Literal".
A static template value part.
An interface for parts of a template that can be visited.
For code generating from a template, use a `TemplateVisitor`.
Provides facilities for evaluating an endpoint rule-set and tests.
Index containing the full set of TextInstances associated with a model.
Contains information about text that occurs in the Smithy IDL written by the owner, inluding location metadata.
Enum type indicating what kind of location in the model associated text appeared in.
Defines a custom serialization format for a timestamp.
The known timestampFormat values.
 
Represents a timestamp shape.
Builder used to create a TimestampShape.
Defines how timestamps are validated.
Provides a human-readable proper noun title to services and resources.
 
Supplies functionality to be coercible into Conditions for use in composing rule-sets in code.
Supplies functionality to be coercible into Expressions for use in composing rule-sets in code.
Provides a labeled tree of tokens returned from IdlTokenizer.
A value that can be converted to a Node.
Provides top-down access to all resources and operations contained within a service or resource closure.
Represents a parsed MQTT topic.
Represents a level in a topic.
Contains computed information about the resolved MQTT topic bindings of an operation.
Binds a member to an MQTT label using the member name.
 
Thrown when an MQTT topic is malformed.
Creates a reverse-topological ordering of shapes.
Topologically sorts shapes based on their dependencies (i.e., mixins).
Thrown when cycles exist between shapes.
Interface used to convert a shape to a ShapeId.
Provides a way to get from an instance of T to a SmithyBuilder.
Class that represents the contents of a Smithy trace file.
Builder for constructing TraceFile's from scratch.
Class that defines information a code-generated artifact.
 
Decorates a SymbolProvider with a TraceFile.Builder and adds a ShapeLink object to the builder on each call to toSymbol.
Builder to create a TracingSymbolProvider instance.
Traits provide additional context and semantics to shapes.
Finds breaking changes related to when a trait is added, removed, or updated based on the breakingChanges property of traits.
Validates that the JSON pointer paths of the breakingChanges property of a trait refers to valid parts of the model.
Validates that traits do not conflict.
Trait definition trait.
Represents an individual trait diff rule to define backward compatibility rules.
Builder to create a TraitDefinition.
 
 
The structural exclusion semantics of the trait.
Creates traits using trait data from a model.
Creates traits from Node values.
Validates that traits are only applied to compatible shapes.
Implementation of smithy.api#traitValidators.
 
 
 
 
Validates that trait values are valid for their trait definitions.
Transform configuration found in a projection.
 
Context object used when applying a ProjectionTransformer.
A visitor for traversing the rules and conditions of a rule-set.
Externally traverses a TokenTree to provide access to parents and siblings.
A rule-set rule that is used to contain condition based branching rules.
Defines the tree type.
Similar to BiConsumer, but accepts three arguments.
A tuple value, containing a list of other literals.
A "tuple" type, containing members of varying types.
Types used to construct conditions out of values in the rules engine.
TypeCheck provides an interface for determining whether the given types within scope satisfy the associated constraints.
Tagged union shape that maps member names to member definitions.
Builder used to create a UnionShape.
 
Indicates that the members of a list must be unique.
 
Validates that the "id" property of smithy.test#httpRequestTests, smithy.test#httpResponseTests, and smithy.test#httpMalformedRequestTests are unique across all test cases.
Validates that smoke test cases have unique IDs within a service closure, or within the trait if it is not connected to a service.
Ensures that no two waiters use the same case-insensitive name in the closure of a service.
 
 
Ensures that a unit type can only be referenced as operation input/output or by a tagged union member.
Thrown when a projection extends from an unknown projection.
Thrown when a mapper cannot be found.
Finds shapes that are not connected to a "root" shape, are not trait definitions, are not referenced by trait definitions, and are not referenced in trait values through IdRefTrait.
Finds shapes that aren't connected to any shapes considered "roots" (defaults to service shapes).
Deprecated.
 
 
Finds trait definitions that are not connected to a service shape.
Indicates that the payload of an operation is not to be signed.
 
Marks a shape as unstable.
 
Emits a validation event if a model contains shapes that are bound to unstable traits.
Logs each instance of traits and features that are known to not work in OpenAPI.
A rule-set function for URI encoding a string.
A FunctionDefinition for the UriEncode function.
Represents a URI pattern.
Represents the result of an operation and the ValidationEvents that occurred.
Thrown when ValidatedResult.validate() is called and the result contains ERROR events.
A validation event created when validating a model.
Builds ValidationEvent values.
Validation event decorators take validation events and transform them by adding more contextual information, usually adding a hint to let the user know what can it be done to solve the issue.
Formats ValidationEvents.
Utility methods used when validating.
Validates a Model and returns a list of ValidationEvent.
Creates built-in Validator instances and Validator instances loaded by name.
Represents a service provider for configurable Validators that appear in Smithy models.
Provides a simple abstraction for creating validator service subclasses.
An abstract representing a typed value.
Indicates that an operation has various named "waiters" that can be used to poll a resource until it enters a desired state.
 
 
 
Defines an individual operation waiter.
 
Walks connected shapes within a Model.
Creates and manages SymbolWriters for files and namespaces based on Symbols created for a Shape.
Marks a structure member to be serialized to/from an XML attribute.
 
 
 
Defines the XML Namespace prefix and URI.
Builder used to create an XmlNamespace trait.
 
Validates that the xmlNamespace traits are applied correctly for structures.
Provides a custom name to use when serializing a structure member name as a XML object property.