Generator diagnostics and errors

Fatal: An issue that prevents code generation entirely.
Error: Undesired or unexpected behavior. Resolve all errors before a 0.0.1 release.
Warning: Potentially undesired or unexpected behavior. Resolve all warnings before a 1.0.0 release.
Note: A potential improvement or misconfiguration. Investigate all notes before a 1.0.0 release.

ClientOpt

`ClientOpt/ShouldBeNullable`

Client opt at client_settings.opts.{clientOptName} should be nullable.

{reason}

Endpoint

`Endpoint/BothSpecifiedAndUnspecified`

{endpoint} is in unspecified_endpoints, but is specified in resources.

An endpoint cannot be both specified and unspecified. Remove it from unspecified_endpoints or resources.

`Endpoint/IsIgnored`

{endpoint} is in unspecified_endpoints so code will not be generated for it.

If this is intentional, then ignore this note. Otherwise, remove the endpoint from unspecified_endpoints and add it to resources.

`Endpoint/NotConfigured`

{endpoint} exists in the OpenAPI spec, but isn't specified in the Stainless config.

Code will not be generated for the endpoint. Did you mean {closestEndpoint}?

`Endpoint/NotFound`

{endpoint} was not found in the OpenAPI spec.

Code will not be generated for the endpoint.

`Endpoint/NotHttp`

{endpoint} is not an HTTP endpoint, but only HTTP endpoints are supported.

An HTTP endpoint must contain:

get, post, put, patch or delete

Then a space

Then a path that begins with a /

Go

`Go/DuplicateVariantDeserializationConditions`

The same deserialization condition deserializes to separate types:

{conditions.0.representation}: gjson={conditions.0.gjsonValue} discriminatorValue={conditions.0.discriminatorValue}
{conditions.1.representation}: gjson={conditions.1.gjsonValue} discriminatorValue={conditions.1.discriminatorValue}

`Go/DuplicateVariantNameForUnion`

Variant names for union {typeName} at {oasRef} overlap, as we could not infer good unique names for the variants.

These are the overlapping schemas:

{variants.0}

{variants.1}

You can assign better names to these schemas by assigning a title or making the variant a model.

`Go/MultipleFormatsInUnion`

Multiple different schema formats found for variants of {oas_path}: {formats.0}, {formats.1}

`Go/SchemaUnionRequiresDiscriminator`

A discriminator field should be present on this union for Go, which helps deserialization.

`Go/SchemaVariantRequiresDiscriminator`

Variant for union requires a property for discriminator {discriminatorPropertyName}

`Go/SchemaVariantTypeNotSupported`

Variant type '{variantType}' is not currently supported

`Go/SnippetNotValid`

Go example snippet did not format correctly

Java

`Java/CollapsedUnionHasRedundantModel`

This union collapses to its enum variant ({collapsedVariant.stainlessPath}), but both are models, so only the enum model will be respected.'

Only annotate either the union or the enum variant as a model.

`Java/SchemaUnionRequiresDiscriminator`

A discriminator field should be present on this union for Java, which helps deserialization.

Java unions with more than one object variant, but no discriminator field, can be inefficient to deserialize at best and ambiguous to deserialize at worst.

`Java/UnsupportedAliasModel`

We currently do not support generating alias models in Java/Kotlin. You will have to remove it from the config.

Method

`Method/BodyRootParamNeedsName`

Encountered method with a non-object request body, defaulting to the name {fallbackName} for the generated method argument.
To change this, set body_param_name in the method config, e.g.
methods:
  my_method:
    type: http
    endpoint: post /examples
    body_param_name: 'items'

`Method/ExpectedMatchPaginationScheme`

Expected method to have matched pagination scheme {paginationScheme} because it was explicitly configured in the method config.

Reasons why matching {result.page} failed:

result.errors.0

result.errors.1

There were matches of these other pagination styles: {otherMatches.0} and {otherMatches.1}

`Method/ExpectedNoPagination`

Expected method to have not matched a pagination scheme because {reason}.
There were matches of these pagination styles:

If the endpoint is paginated, you can disable this diagnostic by setting paginated to true in the method config.

Example:
methods:
  my_method:
    type: http
    endpoint: get /examples
    paginated: true

By default Stainless expects methods for paginated endpoints to be prefixed with list. That's a simple and common convention that helps users understand that the method is paginated.

If you have a use case for a paginated method that doesn't follow that convention, you can disable this diagnostic by setting paginated to true in the method config.

methods:
  my_method:
    type: http
    endpoint: get /examples
    paginated: true

`Method/ExpectedPagination`

Expected {stainlessPath} to have matched a pagination scheme because {reason}.
Pagination schemes:

{results.0.page}:

results.0.errors.0

results.0.errors.1

{results.1.page}:

results.1.errors.0

results.1.errors.1

If the endpoint is not paginated, you can disable this diagnostic by setting paginated to false in the method config.

Example:
methods:
  my_method:
    type: http
    endpoint: get /examples
    paginated: false

By default Stainless expects methods prefixed with list to be paginated. That's a simple and common convention that helps users understand that the method is paginated.

If you have a use case for a paginated method that doesn't follow that convention, you can disable this diagnostic by setting paginated to true in the method config.

methods:
  my_method:
    type: http
    endpoint: get /examples
    paginated: false

`Method/MatchedMultiplePages`

Found multiple matching pagination schemes, {pages.0} and {pages.1}. Add an explicit pagination: {page_name} to the method definition to disambiguate.

`Method/NameNotValid`

Method name invalid, please rename it: {reason}

`Method/PathComponentMissingParameter`

This endpoint is missing a parameter for path component {component}.

`Method/PathHasRepeatedComponent`

This endpoint has duplicate path component {component} in the path {endpoint}, which may not be intended.

`Method/RequestBodyHasAdditionalProperties`

Request params schema defines additionalProperties but it will be ignored

`Method/RequestBodyNotSupported`

The endpoint is a GET method but has a request body. This is not recommended and will crash for JS fetch users.

This is usually a mistake in the spec, and can be resolved by removing the request body from the endpoint. If this is how your API works, we suggest you change your API, as some javascript runtimes do not support this, and neither does the Go standard library.

`Method/SuccessResponseNotFound`

Could not find a response with a supported 2xx status code and Content-Type.

To fix, either the model at {stainlessPath} should be removed or a response definition for {endpoint} should be added.

Model

`Model/DuplicateDefinition`

Schema {refName} is already declared as a model at {existingModelName}; One of the model definitions should be removed.

`Model/DuplicateName`

Another model with name {existingModelName} already exists. Models should always have a unique name, or a unique namespaced name under a resource declared as a standalone_api.

`Model/IsIndirect`

{configRef} points to a schema with an indirect $ref: {schemaRef}, maybe it should point to that instead?

`Model/NeedsRename`

Consider renaming model {model.rawName}; e.g. {suggestion}'

`Model/ParamsSuffixNameClash`

Model config no_params_suffix is set to true but the schema is used in a response so removing the suffix would cause a name clash.

`Model/Recommended`

Schema at {oasRef} should potentially be declared as a model within {resourceRecommendation}.

The Stainless code generator duplicates definitions for a schema if it appears in multiple places. A schema defined as a model, however, is only declared once and referenced to multiple times.

The generator detected that this schema has had many declarations, and should maybe be defined as a model instead.

OAS

`OAS/InvalidExample`

Example is not valid for schema

Example: {}

{reason}

`OAS/InvalidUnionExample`

Could not find matching variant for the given example {}

`OAS/ReferenceNotFound`

Reference pointed to by {refLocation} is missing from spec: {missingPointer}

Pagination

`Pagination/DuplicateName`

A pagination config with the name {name} was declared multiple times.
These pagination configs conflict with each other:
pagination:
  {indices.0}: { name: {name}, … }
  {indices.1}: { name: {name}, … }

`Pagination/DuplicatePurpose`

Pagination purpose '{purpose}' should only be defined once but it was defined {amount} times.

`Pagination/ExpectedItemsToBeObject`

Expected paginated items schema to be an 'object' type.

`Pagination/MissingProperty`

Could not infer a response property with a '{purpose}' purpose as there were 15 applicable properties {inferredSchemas.0.schema.propertyInfo.key} and {inferredSchemas.1.schema.propertyInfo.key}.
You need to explicitly declare which response property should be used {usedFor}. For example:
{in}:
  {example}

`Pagination/UnsupportedItemsSchemaType`

The paginated items schema must be an 'array' type, received '{schema.type}'.

`Pagination/UnsupportedPurposePlacement`

Explicit pagination purpose '{purpose}' can only be set for schemas within object properties but it was set on a schema with a {schema.parent.type} parent.

`Pagination/UnusedPurposeConfig`

Explicit pagination purpose config is defined but it was not used. Is '{schema.rawSchema.x-stainless-pagination-property.purpose}' a supported purpose for the '{page.type}' pagination type?

ParamModel

`ParamModel/ResponseAndParamPropertySchemasMismatch`

Property {mismatchedPropertyName}'s schema mismatches the same property on {paramSchema.stainlessPath}.

The property will be ignored when generating {cannotGenerateName} for {responseModel.stainlessPath}.

`ParamModel/ResponseAndParamSchemasMismatch`

Cannot generate {cannotGenerateName} for {responseModel.stainlessPath}.

{responseModel.rawName}'s schema is incompatible with {paramModel.stainlessPath}'s schema.

`ParamModel/ResponseSchemaMissingRequiredParamSchemaProperty`

Missing matching required property {missingPropertyName} present on {paramSchema.stainlessPath}.

These properties must match to generate {cannotGenerateName} for {responseModel.stainlessPath}.

Parameter

`Parameter/DuplicateName`

Found parameter with duplicate parameter name {param.name} in {param.location}.
This should be explicitly renamed using x-stainless-param:
- command: mergeObject
  reason: ...
  args:
    target: '{param.method.jsonPath}.parameters[?(@.name == "{param.key}" && @.in == "{param.location}")].schema'
    object:
      x-stainless-param: other_{param.name}

`Parameter/HeaderIsNullable`

A header parameter of type: null or with nullable: true is not supported and will be ignored

`Parameter/MissingName`

The parameter name is missing or empty. It should be given a name.

`Parameter/MissingSchema`

No schema for parameter is defined, assuming it's a schema of type: string

`Parameter/NameHasBrackets`

Parameter has supplied name {parameterName}, the trailing [] was stripped for the SDK parameter name.

`Parameter/NotFound`

Got an unknown param in positional_params: {stainlessPath}

`Parameter/PathIsNullable`

A path parameter of type: null or with nullable: true is not supported and will be ignored

`Parameter/SchemaTypeNotValid`

Schema type {type} is not a valid path param type; Expected one of {supportedTypes.0} or {supportedTypes.1}

Python

`Python/DuplicateDeclaration`

We generated two separated types under the same name: {typename}. If they are the referring to the same type, they should be extracted to the same ref and be declared as a model. Otherwise, they should be renamed with x-stainless-naming

`Python/PackageNameNotAllowed`

Package name {packageName} is not allowed.

`Python/PyPiPackageNameDeprecated`

targets.python.publish.pypi.package_name is deprecated, please remove it in favour of targets.python.project_name

`Python/RequestParamShadowsDefault`

Request param '{name}' would shadow a request option with the same name

QuerySettings

`QuerySettings/BracketsFormatMustBeSet`

The spec names array query params with brackets (e.g my_param[]). To support this, configure query_settings.array_format: brackets in the Stainless config.

Readme

`Readme/MissingPaginationSnippet`

Pagination has been configured but there is no readme.example_requests.pagination snippet defined

`Readme/MissingStreamingSnippet`

Streaming has been configured but there is no readme.example_requests.streaming snippet defined

ReadmeExample

`ReadmeExample/CustomConfigNotValid`

{reason}

`ReadmeExample/MethodNotPaginated`

Expected method {method.name} to be paginated

`ReadmeExample/MethodNotStreaming`

Expected method {method.name} to be streamed

`ReadmeExample/MissingNestedParam`

Expected the given example params to include a nested object; The '{suggestion.method.endpoint}' endpoint has a nested parameter, '{suggestion.param.key}'.

`ReadmeExample/UnknownProperty`

{reason}

Reference

`Reference/NotASchema`

Model path for {stainlessPath} resolved to a value that doesn't look like a schema object, {}

`Reference/NotFound`

Cannot find schema {ref} in OpenAPI spec.

Did you mean: {closest}?

Resource

`Resource/HasConflict`

{paths.0} has a name that conflicts with one or more resources.

Merging these resources into one will resolve the error:

{paths.0}

{paths.1}

Response

`Response/SchemaTypeNotValidForText`

Expected schema with type: 'string' for content type {contentType}

`Response/TypeNotObjectForEnvelope`

unwrap_response_fields has been set but the method's response type is {responseType} not object.

Envelope unwrapping only supports top-level response schemas with type: object and type: allOf. You may want to re-define the response schema, or turn off response unwrapping for this method by setting unwrap_response to false.

`Response/UnsupportedContentType`

Did not find a supported operation response content type; Received {contentTypes.0} and {contentTypes.1}

`Response/UnsupportedHeaderType`

Unexpected non-primitive type: {type} for response header schema: {name}

Ruby

`Ruby/MultipleNamedModelsInIntersection`

Multiple named models found in intersection, currently only 1 named model is supported: - {modelNames.0} - {modelNames.1}

`Ruby/NameNotAllowed`

Renamed illegal Ruby identifier from "{name}" to "{newName}", because {reason}.

Please rename it using the 'renameValue' transform.

`Ruby/NameShadowedBuiltin`

Renamed Ruby method from "{name}" to "{newName}" to avoid shadowing a built-in method.

Please rename it using the 'renameValue' transform.

`Ruby/PaginationTypeUnsupported`

The beta Ruby SDK generator does not yet support {type} pagination

`Ruby/SnippetNotFormatted`

Ruby snippet did not format correctly and may have a syntax error.

`Ruby/UnexpectedParams`

Unable to generate a method corresponding to the params in this method

`Ruby/UnimplementedType`

The beta Ruby SDK generator is not yet able to emit code for type {schema.type}; values will be passed through as-is and documented as Object for now

`Ruby/UnnamedType`

The beta Ruby SDK generator is not yet able to pick a meaningful name for this type, will use {generatedName} for now

Schema

`Schema/CannotInferEnumMemberName`

Could not generate name for enum member {memberName} in language {language}

`Schema/CannotInferName`

Sorry, the {language} codegen currently doesn't support inferring the name for this specific schema.

To explicitly set a schema name, either

set a title property on the schema

set a x-stainless-name OpenAPI extension on the schema

or extract that part of the OpenAPI spec to its own named schema component

For some languages and schemas, Stainless isn't able to infer a name. This is usually because the schema is too complex or ambiguous for a valid name to be generated. E.g. {oneOf: [{type: 'array', items: {oneOf: [...]}}]}.

To fix this, you can set a name explicitly in the schema via the title property, the x-stainless-name OpenAPI extension, or by extracting the problematic schema to its own named component.

`Schema/CannotInferUnionVariantName`

Could not infer a name for the union variant.

The name for a union variant is inferred from

a model definition

a title property on a schema

or a x-stainless-variantName OpenAPI extension on the schema

`Schema/DiscriminatedUnionVariantMissingProperty`

Union variant doesn't define the property discriminator {propertyName} which is required as the union schema defines discriminator.propertyName

`Schema/EnumDescriptionNotValid`

{reason}

`Schema/EnumDuplicateMembers`

Enum has duplicate members: {duplicates.0} or {duplicates.1}

`Schema/EnumIsAmbiguous`

Schema defines an enum property that only includes null.

Either at least one member should be added, or use nullable: true or type: null instead of enum.

`Schema/EnumMemberTypeNotValid`

Enum member has type {} which is not a primitive type.

To fix, you may want to use a oneOf or anyOf instead of an enum definition.

`Schema/ExternalReference`

Schema $ref {} could not be resolved, is it an external reference? e.g. file or url

`Schema/InconsistentEnumMembers`

Inconsistent enum member type encountered, expected {expectedType} but received object

`Schema/IsAmbiguous`

This schema object does not have at least one of type, oneOf, anyOf, or allOf, so its type has been interpreted as unknown.

In most cases the solution is to edit the OpenAPI spec and add a type.

If you meant for the schema to accept anything, add x-stainless-any to suppress this message. Or you may want to use the replaceMatchingSchemas transform.

`Schema/MultipleEnumMemberTypes`

Found enum members with different types ({} and {}). To fix, this should likely be an anyOf instead.

`Schema/ObjectHasNoProperties`

{oasRef} has neither properties nor additionalProperties so its type has been interpreted as unknown.

If the schema should be a map, then add additionalProperties to it.

If the schema should be an empty object type, then add x-stainless-empty-object: true to it. A schema with just type: object and no other information is not interpreted as an empty object type.

`Schema/RecursiveMustBeModel`

Schema $ref: '{recursiveRefName}' is recursively referenced and should be added as a model to the Stainless config.

`Schema/RequiredPropertyNotDefined`

Found properties in required that aren't defined as properties ({} and {}).

To fix, either those entries should be removed from required or added to properties.

`Schema/StringFormatNotSupported`

Unknown schema format format: {format}

`Schema/TypeMissing`

Schema is missing a type property, and it was not automatically inferred.

`Schema/TypeNotValid`

Schema type {type} is not a part of the JSON Schema specification and not supported by Stainless.

Security

`Security/InvalidSchemeRole`

{invalidRole} is not a valid auth role for security scheme {securitySchemeName}. Valid options are {validRoles.0} and {validRoles.1}.

`Security/MissingConfiguration`

No valid root-level 'security' section in your Stainless config or OpenAPI specification files, so authentication is not configured for your SDKs. See https://app.stainlessapi.com/docs/guides/configure#authentication for details.

`Security/SchemeNotFound`

Could not find security scheme: {securitySchemeName}

`Security/SchemeNotSupported`

Security scheme not yet supported: {securitySchemeName}. Please contact support@stainlessapi.com with your use-case, and we can likely add this.

`Security/SchemeNotValid`

Invalid security scheme '{securitySchemeName}': {reason}

Streaming

`Streaming/CannotInferParamsName`

No model name, $ref or streaming.param_type_name defined - using default params type name

`Streaming/UnsupportedParamsStructure`

Streaming method uses a union type for request params which is not supported yet.

Terraform

`Terraform/DataSourceAttributeTypeMismatch`

({resource.name}) resource has multiple methods with conflicting types for attribute {}, which is omitted as a data source parameter.

`Terraform/PotentiallyConfusingPaginationAttribute`

({resource.name}) resource has a property with the name {} which could be a pagination attribute that should be abstracted away in Terraform.

`Terraform/ResourceCannotBeInferred`

({resourceName}) {detail}

`Terraform/ResourceHasAmbiguousProperties`

({resourceName}) resource has some properties with an undefined type, which results in a raw JSON field. To resolve, add type annotations to the following properties:

{properties.0}

{properties.1}

`Terraform/ResourceHasNamingCollision`

({resource.name}) resource has a property with the name {} which conflicts with the name of the {} {attributeType} attribute. As an interim measure, To resolve, please {customerAction}.

`Terraform/UnknownInUnion`

One of the variants in a union has an undefined type, so it was omitted. Add type annotations to the variant have it included, or use x-stainless-skip to omit the variant explicitly.

`Terraform/UnsupportedDeleteBehaviorUnspecified`

({resourceName}) Could not find a delete operation. If the resource does not support deletion, provide a value for 'unsupported_delete_behavior'.

`Terraform/UnsupportedQueryType`

({resource.name}) resource has a property {} of type {} which is currently unsupported in Terraform.

`Terraform/UnsupportedRequest`

({resourceName}) resource has an unsupported request type ({requestType}) in method {method.name}. Supported response types are: {supportedRequestTypes.0}, {supportedRequestTypes.1}.

`Terraform/UnsupportedResponse`

({resourceName}) resource has an unsupported response type ({responseType}) in method {method.name}, and will be ignored. Supported response types are: {supportedResponseTypes.0}, {supportedResponseTypes.1}.

Transform

`Transform/Failed`

Transformation {command} at step {step} exited with a failure

{message}

Unsupported

`Unsupported/MixOfArrayQueryParamFormat`

The OpenAPI spec has a mixture of bracket and non-bracket query params, which is not supported by Stainless.

`Unsupported/WebhookUnwrap`

Webhook unwrap method tests are not currently supported for {language}

Misc

`BootstrapCommandError`

A bootstrap command reported an error: {command}

`FatalError`

Fatal error while generating code

`FormatterCommandError`

A formatter reported an error: {command}

`InvalidInternalState`

{message}

`LinterCommandError`

A linter reported issues: {command}

`TestCommandError`

A test command reported an error: {command}

ClientOpt​

Endpoint​

Go​

Java​

Method​

Model​

OAS​

Pagination​

ParamModel​

Parameter​

Python​

QuerySettings​

Readme​

ReadmeExample​

Reference​

Resource​

Response​

Ruby​

Schema​

Security​

Streaming​

Terraform​

Transform​

Unsupported​

ClientOpt

Endpoint

Go

Java

Method

Model

OAS

Pagination

ParamModel

Parameter

Python

QuerySettings

Readme

ReadmeExample

Reference

Resource

Response

Ruby

Schema

Security

Streaming

Terraform

Transform

Unsupported