diff --git a/clients/aws-sdk-bedrock-runtime/.changes/next-release/aws-sdk-bedrock-runtime-enhancement-9c8ffa23c5a94db3beea927d3b754f6e.json b/clients/aws-sdk-bedrock-runtime/.changes/next-release/aws-sdk-bedrock-runtime-enhancement-9c8ffa23c5a94db3beea927d3b754f6e.json new file mode 100644 index 00000000..f3721eb4 --- /dev/null +++ b/clients/aws-sdk-bedrock-runtime/.changes/next-release/aws-sdk-bedrock-runtime-enhancement-9c8ffa23c5a94db3beea927d3b754f6e.json @@ -0,0 +1,4 @@ +{ + "type": "enhancement", + "description": "Regenerate the Bedrock Runtime client with the current Smithy compact-schema API for compatibility with the shared runtime." +} \ No newline at end of file diff --git a/clients/aws-sdk-bedrock-runtime/.changes/next-release/aws-sdk-bedrock-runtime-feature-0215e886f8084bdd9303da46e8740056.json b/clients/aws-sdk-bedrock-runtime/.changes/next-release/aws-sdk-bedrock-runtime-feature-0215e886f8084bdd9303da46e8740056.json new file mode 100644 index 00000000..7c70e301 --- /dev/null +++ b/clients/aws-sdk-bedrock-runtime/.changes/next-release/aws-sdk-bedrock-runtime-feature-0215e886f8084bdd9303da46e8740056.json @@ -0,0 +1,4 @@ +{ + "type": "feature", + "description": "Document and validate inherited request-compression configuration for the Bedrock Runtime client. Explicit gzip requires operation support; current Bedrock operations remain unsupported." +} diff --git a/clients/aws-sdk-bedrock-runtime/README.md b/clients/aws-sdk-bedrock-runtime/README.md index 9fc85a63..bdea74d9 100644 --- a/clients/aws-sdk-bedrock-runtime/README.md +++ b/clients/aws-sdk-bedrock-runtime/README.md @@ -18,3 +18,39 @@ python -m pip install aws-sdk-bedrock-runtime the Bedrock Runtime client, available operations, and types. - [Developer Guide](https://docs.aws.amazon.com/sdk-for-python/v4/guide/) - configuration, authentication, and usage of the AWS SDK for Python v4. + +## Request compression + +Request compression reduces the bytes uploaded to an operation that advertises +gzip support. It does not reduce model input tokens. The client exposes three +configuration settings: + +- `disable_request_compression`: disable automatic compression. +- `request_min_compression_size_bytes`: the automatic compression threshold, + defaulting to 10,240 bytes. +- `request_compression_encoding`: explicitly select `"gzip"` regardless of the + threshold, or leave it as `None` for automatic behavior. + +For an operation with advertised gzip support, explicit configuration is: + +```python +from aws_sdk_bedrock_runtime.config import AsyncBedrockRuntimeConfig + +config = await AsyncBedrockRuntimeConfig.resolve( + region="us-east-1", + request_compression_encoding="gzip", +) +``` + +The current Bedrock Runtime service model does not advertise request compression. +Leave the explicit encoding unset for current Bedrock operations. Selecting gzip +on an unsupported operation fails before sending a request; the SDK does not +silently send an uncompressed request. Disabling compression while explicitly +selecting gzip is also invalid. Zstd is not currently supported. + +The configuration cannot enable server-side compression support. Bedrock and +Mantle endpoints must accept compressed requests before applications can use it +with those endpoints. + +This client covers modeled Bedrock Runtime operations. Mantle's provider-compatible +APIs use a separate client integration and need compression support there too. diff --git a/clients/aws-sdk-bedrock-runtime/src/aws_sdk_bedrock_runtime/_private/schemas.py b/clients/aws-sdk-bedrock-runtime/src/aws_sdk_bedrock_runtime/_private/schemas.py index e7478788..4a07d939 100644 --- a/clients/aws-sdk-bedrock-runtime/src/aws_sdk_bedrock_runtime/_private/schemas.py +++ b/clients/aws-sdk-bedrock-runtime/src/aws_sdk_bedrock_runtime/_private/schemas.py @@ -2,4166 +2,4114 @@ from types import MappingProxyType -from smithy_core.prelude import ( - BLOB, - BOOLEAN, - DOCUMENT, - DOUBLE, - FLOAT, - INTEGER, - LONG, - STRING, - UNIT, +from smithy_core._schema_compact import StaticOperationSchema, StaticSchema + + +n0 = "com.amazonaws.bedrockruntime" +_NBS = "NonBlankString" +_ADE = "AccessDeniedException" +_s = "smithy.api#error" +_c = "client" +_sE = "smithy.api#httpError" +_m = "message" +_AI = "AccountId" +_AMRFP = "AdditionalModelResponseFieldPaths" +_me = "member" +_IA = "InvocationArn" +_GAII = "GetAsyncInvokeInput" +_sSI = "smithy.synthetic#originalShapeId" +_cGAIR = "com.amazonaws.bedrockruntime#GetAsyncInvokeRequest" +_iA = "invocationArn" +_sm = "smithy.api#required" +_sL = "smithy.api#httpLabel" +_AIIT = "AsyncInvokeIdempotencyToken" +_T = "Timestamp" +_sF = "smithy.api#timestampFormat" +_dt = "date-time" +_AIM = "AsyncInvokeMessage" +_smi = "smithy.api#sensitive" +_AIA = "AsyncInvokeArn" +_KKI = "KmsKeyId" +_SU = "S3Uri" +_AISODC = "AsyncInvokeS3OutputDataConfig" +_sU = "s3Uri" +_kKI = "kmsKeyId" +_bO = "bucketOwner" +_AIODC = "AsyncInvokeOutputDataConfig" +_sODC = "s3OutputDataConfig" +_AIS = "AsyncInvokeStatus" +_IP = "IN_PROGRESS" +_COMPLETED = "COMPLETED" +_FAILED = "FAILED" +_GAIO = "GetAsyncInvokeOutput" +_cGAIRo = "com.amazonaws.bedrockruntime#GetAsyncInvokeResponse" +_mA = "modelArn" +_cRT = "clientRequestToken" +_st = "status" +_fM = "failureMessage" +_sT = "submitTime" +_lMT = "lastModifiedTime" +_eT = "endTime" +_oDC = "outputDataConfig" +_ISE = "InternalServerException" +_se = "server" +_TE = "ThrottlingException" +_VE = "ValidationException" +_GAI = "GetAsyncInvoke" +_smit = "smithy.api#http" +_MR = "MaxResults" +_PT = "PaginationToken" +_SAIB = "SortAsyncInvocationBy" +_ST = "SUBMISSION_TIME" +_SO = "SortOrder" +_ASCENDING = "ASCENDING" +_DESCENDING = "DESCENDING" +_LAII = "ListAsyncInvokesInput" +_cLAIR = "com.amazonaws.bedrockruntime#ListAsyncInvokesRequest" +_sTA = "submitTimeAfter" +_sQ = "smithy.api#httpQuery" +_sTB = "submitTimeBefore" +_sEt = "statusEquals" +_mR = "maxResults" +_nT = "nextToken" +_sB = "sortBy" +_smith = "smithy.api#default" +_STu = "SubmissionTime" +_sO = "sortOrder" +_D = "Descending" +_AISs = "AsyncInvokeSummary" +_AISsy = "AsyncInvokeSummaries" +_LAIO = "ListAsyncInvokesOutput" +_cLAIRo = "com.amazonaws.bedrockruntime#ListAsyncInvokesResponse" +_aIS = "asyncInvokeSummaries" +_LAI = "ListAsyncInvokes" +_CE = "ConflictException" +_RNFE = "ResourceNotFoundException" +_SQEE = "ServiceQuotaExceededException" +_SUE = "ServiceUnavailableException" +_AII = "AsyncInvokeIdentifier" +_MIP = "ModelInputPayload" +_TK = "TagKey" +_TV = "TagValue" +_Ta = "Tag" +_k = "key" +_v = "value" +_TL = "TagList" +_SAII = "StartAsyncInvokeInput" +_cSAIR = "com.amazonaws.bedrockruntime#StartAsyncInvokeRequest" +_sTm = "smithy.api#idempotencyToken" +_mI = "modelId" +_mIo = "modelInput" +_t = "tags" +_SAIO = "StartAsyncInvokeOutput" +_cSAIRo = "com.amazonaws.bedrockruntime#StartAsyncInvokeResponse" +_SAI = "StartAsyncInvoke" +_GIF = "GuardrailImageFormat" +_PNG = "PNG" +_JPEG = "JPEG" +_GIS = "GuardrailImageSource" +_b = "bytes" +_GIB = "GuardrailImageBlock" +_f = "format" +_so = "source" +_GCQ = "GuardrailContentQualifier" +_GS = "GROUNDING_SOURCE" +_QUERY = "QUERY" +_GC = "GUARD_CONTENT" +_GCQL = "GuardrailContentQualifierList" +_GTB = "GuardrailTextBlock" +_te = "text" +_q = "qualifiers" +_GCB = "GuardrailContentBlock" +_i = "image" +_GCBL = "GuardrailContentBlockList" +_GI = "GuardrailIdentifier" +_GV = "GuardrailVersion" +_GOS = "GuardrailOutputScope" +_INTERVENTIONS = "INTERVENTIONS" +_FULL = "FULL" +_GCS = "GuardrailContentSource" +_INPUT = "INPUT" +_OUTPUT = "OUTPUT" +_AGI = "ApplyGuardrailInput" +_cAGR = "com.amazonaws.bedrockruntime#ApplyGuardrailRequest" +_gI = "guardrailIdentifier" +_gV = "guardrailVersion" +_co = "content" +_oS = "outputScope" +_GA = "GuardrailAction" +_NONE = "NONE" +_GI_ = "GUARDRAIL_INTERVENED" +_GAu = "GuardrailArn" +_GIu = "GuardrailId" +_GO = "GuardrailOrigin" +_REQUEST = "REQUEST" +_AE = "ACCOUNT_ENFORCED" +_OE = "ORGANIZATION_ENFORCED" +_GOL = "GuardrailOriginList" +_GOu = "GuardrailOwnership" +_SELF = "SELF" +_CA = "CROSS_ACCOUNT" +_AGD = "AppliedGuardrailDetails" +_gIu = "guardrailId" +_gA = "guardrailArn" +_gO = "guardrailOrigin" +_gOu = "guardrailOwnership" +_ARRI = "AutomatedReasoningRuleIdentifier" +_GARPVA = "GuardrailAutomatedReasoningPolicyVersionArn" +_GARR = "GuardrailAutomatedReasoningRule" +_id = "identifier" +_pVA = "policyVersionArn" +_GARRL = "GuardrailAutomatedReasoningRuleList" +_GARSLC = "GuardrailAutomatedReasoningStatementLogicContent" +_GARSNLC = "GuardrailAutomatedReasoningStatementNaturalLanguageContent" +_GARS = "GuardrailAutomatedReasoningStatement" +_l = "logic" +_nL = "naturalLanguage" +_GARSL = "GuardrailAutomatedReasoningStatementList" +_GARLWT = "GuardrailAutomatedReasoningLogicWarningType" +_AF = "ALWAYS_FALSE" +_AT = "ALWAYS_TRUE" +_GARLW = "GuardrailAutomatedReasoningLogicWarning" +_ty = "type" +_p = "premises" +_cl = "claims" +_GARTC = "GuardrailAutomatedReasoningTranslationConfidence" +_GARITR = "GuardrailAutomatedReasoningInputTextReference" +_GARITRL = "GuardrailAutomatedReasoningInputTextReferenceList" +_GART = "GuardrailAutomatedReasoningTranslation" +_uP = "untranslatedPremises" +_uC = "untranslatedClaims" +_con = "confidence" +_GARIF = "GuardrailAutomatedReasoningImpossibleFinding" +_tr = "translation" +_cR = "contradictingRules" +_lW = "logicWarning" +_GARIFu = "GuardrailAutomatedReasoningInvalidFinding" +_GARNTF = "GuardrailAutomatedReasoningNoTranslationsFinding" +_GARSu = "GuardrailAutomatedReasoningScenario" +_sta = "statements" +_GARSF = "GuardrailAutomatedReasoningSatisfiableFinding" +_cTS = "claimsTrueScenario" +_cFS = "claimsFalseScenario" +_GARTCF = "GuardrailAutomatedReasoningTooComplexFinding" +_GARDSL = "GuardrailAutomatedReasoningDifferenceScenarioList" +_GARTL = "GuardrailAutomatedReasoningTranslationList" +_GARTO = "GuardrailAutomatedReasoningTranslationOption" +_tra = "translations" +_GARTOL = "GuardrailAutomatedReasoningTranslationOptionList" +_GARTAF = "GuardrailAutomatedReasoningTranslationAmbiguousFinding" +_o = "options" +_dS = "differenceScenarios" +_GARVF = "GuardrailAutomatedReasoningValidFinding" +_sR = "supportingRules" +_GARF = "GuardrailAutomatedReasoningFinding" +_va = "valid" +_in = "invalid" +_sa = "satisfiable" +_im = "impossible" +_tA = "translationAmbiguous" +_tC = "tooComplex" +_nTo = "noTranslations" +_GARFL = "GuardrailAutomatedReasoningFindingList" +_GARPA = "GuardrailAutomatedReasoningPolicyAssessment" +_fi = "findings" +_GCPA = "GuardrailContentPolicyAction" +_BLOCKED = "BLOCKED" +_GCFC = "GuardrailContentFilterConfidence" +_LOW = "LOW" +_MEDIUM = "MEDIUM" +_HIGH = "HIGH" +_GCFS = "GuardrailContentFilterStrength" +_GCFT = "GuardrailContentFilterType" +_INSULTS = "INSULTS" +_HATE = "HATE" +_SEXUAL = "SEXUAL" +_VIOLENCE = "VIOLENCE" +_MISCONDUCT = "MISCONDUCT" +_PA = "PROMPT_ATTACK" +_GCF = "GuardrailContentFilter" +_fS = "filterStrength" +_a = "action" +_d = "detected" +_GCFL = "GuardrailContentFilterList" +_GCPAu = "GuardrailContentPolicyAssessment" +_fil = "filters" +_GCGPA = "GuardrailContextualGroundingPolicyAction" +_GCGFT = "GuardrailContextualGroundingFilterType" +_GROUNDING = "GROUNDING" +_RELEVANCE = "RELEVANCE" +_GCGF = "GuardrailContextualGroundingFilter" +_th = "threshold" +_sc = "score" +_GCGFu = "GuardrailContextualGroundingFilters" +_GCGPAu = "GuardrailContextualGroundingPolicyAssessment" +_IG = "ImagesGuarded" +_IT = "ImagesTotal" +_GIC = "GuardrailImageCoverage" +_g = "guarded" +_to = "total" +_TCG = "TextCharactersGuarded" +_TCT = "TextCharactersTotal" +_GTCC = "GuardrailTextCharactersCoverage" +_GCu = "GuardrailCoverage" +_tCe = "textCharacters" +_ima = "images" +_GPL = "GuardrailProcessingLatency" +_GARPP = "GuardrailAutomatedReasoningPoliciesProcessed" +_GARPUP = "GuardrailAutomatedReasoningPolicyUnitsProcessed" +_GCPIUP = "GuardrailContentPolicyImageUnitsProcessed" +_GCPUP = "GuardrailContentPolicyUnitsProcessed" +_GCGPUP = "GuardrailContextualGroundingPolicyUnitsProcessed" +_GSIPFUP = "GuardrailSensitiveInformationPolicyFreeUnitsProcessed" +_GSIPUP = "GuardrailSensitiveInformationPolicyUnitsProcessed" +_GTPUP = "GuardrailTopicPolicyUnitsProcessed" +_GWPUP = "GuardrailWordPolicyUnitsProcessed" +_GU = "GuardrailUsage" +_tPU = "topicPolicyUnits" +_cPU = "contentPolicyUnits" +_wPU = "wordPolicyUnits" +_sIPU = "sensitiveInformationPolicyUnits" +_sIPFU = "sensitiveInformationPolicyFreeUnits" +_cGPU = "contextualGroundingPolicyUnits" +_cPIU = "contentPolicyImageUnits" +_aRPU = "automatedReasoningPolicyUnits" +_aRP = "automatedReasoningPolicies" +_GIM = "GuardrailInvocationMetrics" +_gPL = "guardrailProcessingLatency" +_u = "usage" +_gC = "guardrailCoverage" +_GSIPA = "GuardrailSensitiveInformationPolicyAction" +_ANONYMIZED = "ANONYMIZED" +_GPET = "GuardrailPiiEntityType" +_ADDRESS = "ADDRESS" +_AGE = "AGE" +_AAK = "AWS_ACCESS_KEY" +_ASK = "AWS_SECRET_KEY" +_CHN = "CA_HEALTH_NUMBER" +_CSIN = "CA_SOCIAL_INSURANCE_NUMBER" +_CDCC = "CREDIT_DEBIT_CARD_CVV" +_CDCE = "CREDIT_DEBIT_CARD_EXPIRY" +_CDCN = "CREDIT_DEBIT_CARD_NUMBER" +_DI = "DRIVER_ID" +_EMAIL = "EMAIL" +_IBAN = "INTERNATIONAL_BANK_ACCOUNT_NUMBER" +_IA_ = "IP_ADDRESS" +_LP = "LICENSE_PLATE" +_MA = "MAC_ADDRESS" +_NAME = "NAME" +_PASSWORD = "PASSWORD" +_PHONE = "PHONE" +_PIN = "PIN" +_SC = "SWIFT_CODE" +_UNHSN = "UK_NATIONAL_HEALTH_SERVICE_NUMBER" +_UNIN = "UK_NATIONAL_INSURANCE_NUMBER" +_UUTRN = "UK_UNIQUE_TAXPAYER_REFERENCE_NUMBER" +_URL = "URL" +_USERNAME = "USERNAME" +_UBAN = "US_BANK_ACCOUNT_NUMBER" +_UBRN = "US_BANK_ROUTING_NUMBER" +_UITIN = "US_INDIVIDUAL_TAX_IDENTIFICATION_NUMBER" +_UPN = "US_PASSPORT_NUMBER" +_USSN = "US_SOCIAL_SECURITY_NUMBER" +_VIN = "VEHICLE_IDENTIFICATION_NUMBER" +_GPEF = "GuardrailPiiEntityFilter" +_ma = "match" +_GPEFL = "GuardrailPiiEntityFilterList" +_GRF = "GuardrailRegexFilter" +_n = "name" +_r = "regex" +_GRFL = "GuardrailRegexFilterList" +_GSIPAu = "GuardrailSensitiveInformationPolicyAssessment" +_pE = "piiEntities" +_re = "regexes" +_GTPA = "GuardrailTopicPolicyAction" +_GTT = "GuardrailTopicType" +_DENY = "DENY" +_GT = "GuardrailTopic" +_GTL = "GuardrailTopicList" +_GTPAu = "GuardrailTopicPolicyAssessment" +_top = "topics" +_GWPA = "GuardrailWordPolicyAction" +_GCW = "GuardrailCustomWord" +_GCWL = "GuardrailCustomWordList" +_GMWT = "GuardrailManagedWordType" +_PROFANITY = "PROFANITY" +_GMW = "GuardrailManagedWord" +_GMWL = "GuardrailManagedWordList" +_GWPAu = "GuardrailWordPolicyAssessment" +_cW = "customWords" +_mWL = "managedWordLists" +_GAua = "GuardrailAssessment" +_tP = "topicPolicy" +_cP = "contentPolicy" +_wP = "wordPolicy" +_sIP = "sensitiveInformationPolicy" +_cGP = "contextualGroundingPolicy" +_aRPu = "automatedReasoningPolicy" +_iM = "invocationMetrics" +_aGD = "appliedGuardrailDetails" +_GAL = "GuardrailAssessmentList" +_GOT = "GuardrailOutputText" +_GOC = "GuardrailOutputContent" +_GOCL = "GuardrailOutputContentList" +_AGO = "ApplyGuardrailOutput" +_cAGRo = "com.amazonaws.bedrockruntime#ApplyGuardrailResponse" +_aR = "actionReason" +_ou = "outputs" +_as = "assessments" +_AG = "ApplyGuardrail" +_GCCFC = "GuardrailChecksContentFilterCategory" +_GCCFCC = "GuardrailChecksContentFilterCategoryConfig" +_ca = "category" +_GCCFCCL = "GuardrailChecksContentFilterCategoryConfigList" +_GCCFCu = "GuardrailChecksContentFilterConfig" +_cat = "categories" +_GCPAC = "GuardrailChecksPromptAttackCategory" +_JAILBREAK = "JAILBREAK" +_PI = "PROMPT_INJECTION" +_PL = "PROMPT_LEAKAGE" +_GCPACC = "GuardrailChecksPromptAttackCategoryConfig" +_GCPACCL = "GuardrailChecksPromptAttackCategoryConfigList" +_GCPACu = "GuardrailChecksPromptAttackConfig" +_GCSIET = "GuardrailChecksSensitiveInformationEntityType" +_GCSIEC = "GuardrailChecksSensitiveInformationEntityConfig" +_GCSIECL = "GuardrailChecksSensitiveInformationEntityConfigList" +_GCSIC = "GuardrailChecksSensitiveInformationConfig" +_e = "entities" +_GCC = "GuardrailChecksConfig" +_cF = "contentFilter" +_pA = "promptAttack" +_sI = "sensitiveInformation" +_GCTC = "GuardrailChecksTextContent" +_GCCB = "GuardrailChecksContentBlock" +_GCCBL = "GuardrailChecksContentBlockList" +_GCR = "GuardrailChecksRole" +_USER = "USER" +_ASSISTANT = "ASSISTANT" +_SYSTEM = "SYSTEM" +_GCM = "GuardrailChecksMessage" +_ro = "role" +_GCML = "GuardrailChecksMessageList" +_IGCI = "InvokeGuardrailChecksInput" +_cIGCR = "com.amazonaws.bedrockruntime#InvokeGuardrailChecksRequest" +_mes = "messages" +_ch = "checks" +_GCCFRE = "GuardrailChecksContentFilterResultEntry" +_sS = "severityScore" +_GCCFRL = "GuardrailChecksContentFilterResultList" +_GCCFR = "GuardrailChecksContentFilterResult" +_res = "results" +_GCPARE = "GuardrailChecksPromptAttackResultEntry" +_GCPARL = "GuardrailChecksPromptAttackResultList" +_GCPAR = "GuardrailChecksPromptAttackResult" +_GCSIRE = "GuardrailChecksSensitiveInformationResultEntry" +_cS = "confidenceScore" +_bOe = "beginOffset" +_eO = "endOffset" +_mIe = "messageIndex" +_cI = "contentIndex" +_GCSIRL = "GuardrailChecksSensitiveInformationResultList" +_GCSIR = "GuardrailChecksSensitiveInformationResult" +_tru = "truncated" +_GCRu = "GuardrailChecksResults" +_GCCFU = "GuardrailChecksContentFilterUsage" +_tU = "textUnits" +_GCPAU = "GuardrailChecksPromptAttackUsage" +_GCSIU = "GuardrailChecksSensitiveInformationUsage" +_GCUR = "GuardrailChecksUsageResults" +_IGCO = "InvokeGuardrailChecksOutput" +_cIGCRo = "com.amazonaws.bedrockruntime#InvokeGuardrailChecksResponse" +_IGC = "InvokeGuardrailChecks" +_GTu = "GuardrailTrace" +_ENABLED = "ENABLED" +_DISABLED = "DISABLED" +_EF = "ENABLED_FULL" +_GCua = "GuardrailConfiguration" +_v_ = "" +_trac = "trace" +_di = "disabled" +_NES = "NonEmptyString" +_NESL = "NonEmptyStringList" +_IC = "InferenceConfiguration" +_mT = "maxTokens" +_tem = "temperature" +_tPo = "topP" +_sSt = "stopSequences" +_EB = "ErrorBlock" +_AFu = "AudioFormat" +_MP = "MP3" +_OPUS = "OPUS" +_WAV = "WAV" +_AAC = "AAC" +_FLAC = "FLAC" +_MP_ = "MP4" +_OGG = "OGG" +_MKV = "MKV" +_MKA = "MKA" +_XA = "X_AAC" +_MA_ = "M4A" +_MPEG = "MPEG" +_MPGA = "MPGA" +_PCM = "PCM" +_WEBM = "WEBM" +_SL = "S3Location" +_ur = "uri" +_AS = "AudioSource" +_sLo = "s3Location" +_AB = "AudioBlock" +_er = "error" +_CTTL = "CacheTTL" +_FM = "FIVE_MINUTES" +_OH = "ONE_HOUR" +_CPT = "CachePointType" +_DEFAULT = "DEFAULT" +_CPB = "CachePointBlock" +_tt = "ttl" +_DCL = "DocumentCharLocation" +_dI = "documentIndex" +_star = "start" +_en = "end" +_DCLo = "DocumentChunkLocation" +_DPL = "DocumentPageLocation" +_SRL = "SearchResultLocation" +_sRI = "searchResultIndex" +_WL = "WebLocation" +_url = "url" +_do = "domain" +_CL = "CitationLocation" +_w = "web" +_dC = "documentChar" +_dP = "documentPage" +_dCo = "documentChunk" +_sRL = "searchResultLocation" +_CSC = "CitationSourceContent" +_CSCL = "CitationSourceContentList" +_C = "Citation" +_ti = "title" +_sC = "sourceContent" +_lo = "location" +_Ci = "Citations" +_CGC = "CitationGeneratedContent" +_CGCL = "CitationGeneratedContentList" +_CCB = "CitationsContentBlock" +_ci = "citations" +_CC = "CitationsConfig" +_ena = "enabled" +_DF = "DocumentFormat" +_PDF = "PDF" +_CSV = "CSV" +_DOC = "DOC" +_DOCX = "DOCX" +_XLS = "XLS" +_XLSX = "XLSX" +_HTML = "HTML" +_TXT = "TXT" +_MD = "MD" +_DCB = "DocumentContentBlock" +_DCBo = "DocumentContentBlocks" +_DS = "DocumentSource" +_DB = "DocumentBlock" +_tx = "txt" +_cont = "context" +_GCIF = "GuardrailConverseImageFormat" +_GCIS = "GuardrailConverseImageSource" +_GCIB = "GuardrailConverseImageBlock" +_GCCQ = "GuardrailConverseContentQualifier" +_GCCQL = "GuardrailConverseContentQualifierList" +_GCTB = "GuardrailConverseTextBlock" +_GCCBu = "GuardrailConverseContentBlock" +_IF = "ImageFormat" +_GIF_ = "GIF" +_WEBP = "WEBP" +_IS = "ImageSource" +_IB = "ImageBlock" +_RTB = "ReasoningTextBlock" +_si = "signature" +_RCB = "ReasoningContentBlock" +_rT = "reasoningText" +_rC = "redactedContent" +_SRCB = "SearchResultContentBlock" +_SRCBe = "SearchResultContentBlocks" +_SRB = "SearchResultBlock" +_TR = "ToolReference" +_sN = "serverName" +_TAB = "ToolAdditionBlock" +_too = "tool" +_TRB = "ToolRemovalBlock" +_VF = "VideoFormat" +_MOV = "MOV" +_FLV = "FLV" +_MPG = "MPG" +_WMV = "WMV" +_TG = "THREE_GP" +_VS = "VideoSource" +_VB = "VideoBlock" +_TRCB = "ToolResultContentBlock" +_j = "json" +_doc = "document" +_vi = "video" +_sRe = "searchResult" +_TRCBo = "ToolResultContentBlocks" +_TRS = "ToolResultStatus" +_SUCCESS = "SUCCESS" +_ERROR = "ERROR" +_TUI = "ToolUseId" +_TRBo = "ToolResultBlock" +_tUI = "toolUseId" +_TN = "ToolName" +_TUT = "ToolUseType" +_STU = "SERVER_TOOL_USE" +_TUB = "ToolUseBlock" +_inp = "input" +_CB = "ContentBlock" +_au = "audio" +_tUo = "toolUse" +_tR = "toolResult" +_gCu = "guardContent" +_cPa = "cachePoint" +_rCe = "reasoningContent" +_cC = "citationsContent" +_tAo = "toolAddition" +_tRo = "toolRemoval" +_CBo = "ContentBlocks" +_CR = "ConversationRole" +_M = "Message" +_Me = "Messages" +_CMI = "ConversationalModelId" +_JSD = "JsonSchemaDefinition" +_sch = "schema" +_de = "description" +_OFS = "OutputFormatStructure" +_jS = "jsonSchema" +_OFT = "OutputFormatType" +_JS = "JSON_SCHEMA" +_OF = "OutputFormat" +_str = "structure" +_OC = "OutputConfig" +_tF = "textFormat" +_ef = "effort" +_PCL = "PerformanceConfigLatency" +_STANDARD = "STANDARD" +_OPTIMIZED = "OPTIMIZED" +_PC = "PerformanceConfiguration" +_la = "latency" +_stan = "standard" +_PVV = "PromptVariableValues" +_PVM = "PromptVariableMap" +_RM = "RequestMetadata" +_STT = "ServiceTierType" +_PRIORITY = "PRIORITY" +_FLEX = "FLEX" +_RESERVED = "RESERVED" +_STe = "ServiceTier" +_SCB = "SystemContentBlock" +_SCBy = "SystemContentBlocks" +_ATC = "AnyToolChoice" +_ATCu = "AutoToolChoice" +_STC = "SpecificToolChoice" +_TC = "ToolChoice" +_aut = "auto" +_an = "any" +_STy = "SystemTool" +_TIS = "ToolInputSchema" +_TS = "ToolSpecification" +_iS = "inputSchema" +_stri = "strict" +_To = "Tool" +_tS = "toolSpec" +_sTy = "systemTool" +_Too = "Tools" +_TCo = "ToolConfiguration" +_tool = "tools" +_tCo = "toolChoice" +_CI = "ConverseInput" +_cCR = "com.amazonaws.bedrockruntime#ConverseRequest" +_sy = "system" +_iC = "inferenceConfig" +_tCoo = "toolConfig" +_gCua = "guardrailConfig" +_aMRF = "additionalModelRequestFields" +_pV = "promptVariables" +_aMRFP = "additionalModelResponseFieldPaths" +_rM = "requestMetadata" +_pC = "performanceConfig" +_sTe = "serviceTier" +_oC = "outputConfig" +_CM = "ConverseMetrics" +_lM = "latencyMs" +_CO = "ConverseOutput" +_SR = "StopReason" +_ET = "END_TURN" +_TU = "TOOL_USE" +_MT = "MAX_TOKENS" +_SS = "STOP_SEQUENCE" +_CF = "CONTENT_FILTERED" +_MMO = "MALFORMED_MODEL_OUTPUT" +_MTU = "MALFORMED_TOOL_USE" +_MCWE = "MODEL_CONTEXT_WINDOW_EXCEEDED" +_GAM = "GuardrailAssessmentMap" +_MO = "ModelOutputs" +_GALM = "GuardrailAssessmentListMap" +_GTA = "GuardrailTraceAssessment" +_mO = "modelOutput" +_iAn = "inputAssessment" +_oA = "outputAssessments" +_IMI = "InvokedModelId" +_PRT = "PromptRouterTrace" +_iMI = "invokedModelId" +_CT = "ConverseTrace" +_gu = "guardrail" +_pR = "promptRouter" +_CD = "CacheDetail" +_iT = "inputTokens" +_CDL = "CacheDetailsList" +_TUo = "TokenUsage" +_oT = "outputTokens" +_tT = "totalTokens" +_cRIT = "cacheReadInputTokens" +_cWIT = "cacheWriteInputTokens" +_cD = "cacheDetails" +_COO = "ConverseOperationOutput" +_cCRo = "com.amazonaws.bedrockruntime#ConverseResponse" +_out = "output" +_sRt = "stopReason" +_met = "metrics" +_aMRFd = "additionalModelResponseFields" +_SCt = "StatusCode" +_MEE = "ModelErrorException" +_oSC = "originalStatusCode" +_rN = "resourceName" +_MNRE = "ModelNotReadyException" +_MTE = "ModelTimeoutException" +_Co = "Converse" +_GSPM = "GuardrailStreamProcessingMode" +_SYNC = "SYNC" +_ASYNC = "ASYNC" +_GSC = "GuardrailStreamConfiguration" +_sPM = "streamProcessingMode" +_syn = "sync" +_CSI = "ConverseStreamInput" +_cCSR = "com.amazonaws.bedrockruntime#ConverseStreamRequest" +_NNI = "NonNegativeInteger" +_CSCD = "CitationSourceContentDelta" +_CSCLD = "CitationSourceContentListDelta" +_CDi = "CitationsDelta" +_IBD = "ImageBlockDelta" +_RCBD = "ReasoningContentBlockDelta" +_TRBD = "ToolResultBlockDelta" +_TRBDo = "ToolResultBlocksDelta" +_TUBD = "ToolUseBlockDelta" +_CBD = "ContentBlockDelta" +_cit = "citation" +_CBDE = "ContentBlockDeltaEvent" +_del = "delta" +_cBI = "contentBlockIndex" +_IBS = "ImageBlockStart" +_TRBS = "ToolResultBlockStart" +_TUBS = "ToolUseBlockStart" +_CBS = "ContentBlockStart" +_CBSE = "ContentBlockStartEvent" +_CBSEo = "ContentBlockStopEvent" +_MSE = "MessageStartEvent" +_MSEe = "MessageStopEvent" +_CSM = "ConverseStreamMetrics" +_CST = "ConverseStreamTrace" +_CSME = "ConverseStreamMetadataEvent" +_MSEE = "ModelStreamErrorException" +_oM = "originalMessage" +_CSO = "ConverseStreamOutput" +_smithy = "smithy.api#streaming" +_mS = "messageStart" +_cBS = "contentBlockStart" +_cBD = "contentBlockDelta" +_cBSo = "contentBlockStop" +_mSe = "messageStop" +_meta = "metadata" +_iSE = "internalServerException" +_mSEE = "modelStreamErrorException" +_vE = "validationException" +_tE = "throttlingException" +_sUE = "serviceUnavailableException" +_CSOO = "ConverseStreamOperationOutput" +_cCSRo = "com.amazonaws.bedrockruntime#ConverseStreamResponse" +_stre = "stream" +_sP = "smithy.api#httpPayload" +_CS = "ConverseStream" +_MTi = "MimeType" +_B = "Body" +_IMIn = "InvokeModelIdentifier" +_RMJ = "RequestMetadataJson" +_Tr = "Trace" +_IMInv = "InvokeModelInput" +_cIMR = "com.amazonaws.bedrockruntime#InvokeModelRequest" +_bo = "body" +_cT = "contentType" +_sH = "smithy.api#httpHeader" +_CT_ = "Content-Type" +_ac = "accept" +_A = "Accept" +_XABT = "X-Amzn-Bedrock-Trace" +_XABG = "X-Amzn-Bedrock-GuardrailIdentifier" +_XABG_ = "X-Amzn-Bedrock-GuardrailVersion" +_pCL = "performanceConfigLatency" +_XABPL = "X-Amzn-Bedrock-PerformanceConfig-Latency" +_XABST = "X-Amzn-Bedrock-Service-Tier" +_XABRM = "X-Amzn-Bedrock-Request-Metadata" +_IMO = "InvokeModelOutput" +_cIMRo = "com.amazonaws.bedrockruntime#InvokeModelResponse" +_IM = "InvokeModel" +_PB = "PartBody" +_BIPP = "BidirectionalInputPayloadPart" +_IMWBSI = "InvokeModelWithBidirectionalStreamInput" +_chu = "chunk" +_IMWBSOI = "InvokeModelWithBidirectionalStreamOperationInput" +_cIMWBSR = "com.amazonaws.bedrockruntime#InvokeModelWithBidirectionalStreamRequest" +_BOPP = "BidirectionalOutputPayloadPart" +_IMWBSO = "InvokeModelWithBidirectionalStreamOutput" +_mTE = "modelTimeoutException" +_IMWBSOO = "InvokeModelWithBidirectionalStreamOperationOutput" +_cIMWBSRo = "com.amazonaws.bedrockruntime#InvokeModelWithBidirectionalStreamResponse" +_IMWBS = "InvokeModelWithBidirectionalStream" +_IMWRSI = "InvokeModelWithResponseStreamInput" +_cIMWRSR = "com.amazonaws.bedrockruntime#InvokeModelWithResponseStreamRequest" +_XABA = "X-Amzn-Bedrock-Accept" +_PP = "PayloadPart" +_RS = "ResponseStream" +_IMWRSO = "InvokeModelWithResponseStreamOutput" +_cIMWRSRo = "com.amazonaws.bedrockruntime#InvokeModelWithResponseStreamResponse" +_XABCT = "X-Amzn-Bedrock-Content-Type" +_IMWRS = "InvokeModelWithResponseStream" +_CTR = "ConverseTokensRequest" +_IMTR = "InvokeModelTokensRequest" +_CTI = "CountTokensInput" +_iMn = "invokeModel" +_conv = "converse" +_FMVI = "FoundationModelVersionIdentifier" +_CTOI = "CountTokensOperationInput" +_cCTR = "com.amazonaws.bedrockruntime#CountTokensRequest" +_CTO = "CountTokensOutput" +_cCTRo = "com.amazonaws.bedrockruntime#CountTokensResponse" +_CTo = "CountTokens" +_ABFS = "AmazonBedrockFrontendService" +_aw = "aws.auth#sigv4" +_sBm = "smithy.rules#endpointBdd" +_aws = "aws.api#service" +_aJ = "aws.protocols#restJson1" +_sBA = "smithy.api#httpBearerAuth" + +NON_BLANK_STRING: StaticSchema = (3, n0, _NBS, 0) + +ACCESS_DENIED_EXCEPTION: StaticSchema = ( + 18, + n0, + _ADE, + {_s: _c, _sE: 403}, + (_m,), + ((NON_BLANK_STRING, 0),), +) + +ACCOUNT_ID: StaticSchema = (3, n0, _AI, 0) + +ADDITIONAL_MODEL_RESPONSE_FIELD_PATHS: StaticSchema = ( + 16, + n0, + _AMRFP, + 0, + (_me,), + ((3, 0),), +) + +INVOCATION_ARN: StaticSchema = (3, n0, _IA, 0) + +GET_ASYNC_INVOKE_INPUT: StaticSchema = ( + 18, + n0, + _GAII, + {_sSI: _cGAIR}, + (_iA,), + ((INVOCATION_ARN, 9),), +) + +ASYNC_INVOKE_IDEMPOTENCY_TOKEN: StaticSchema = (3, n0, _AIIT, 0) + +TIMESTAMP: StaticSchema = (4, n0, _T, {_sF: _dt}) + +ASYNC_INVOKE_MESSAGE: StaticSchema = (3, n0, _AIM, 4) + +ASYNC_INVOKE_ARN: StaticSchema = (3, n0, _AIA, 0) + +KMS_KEY_ID: StaticSchema = (3, n0, _KKI, 0) + +S3_URI: StaticSchema = (3, n0, _SU, 0) + +ASYNC_INVOKE_S3_OUTPUT_DATA_CONFIG: StaticSchema = ( + 18, + n0, + _AISODC, + 0, + (_sU, _kKI, _bO), + ((S3_URI, 1), (KMS_KEY_ID, 0), (ACCOUNT_ID, 0)), +) + +ASYNC_INVOKE_OUTPUT_DATA_CONFIG: StaticSchema = ( + 19, + n0, + _AIODC, + 0, + (_sODC,), + ((ASYNC_INVOKE_S3_OUTPUT_DATA_CONFIG, 0),), +) + +ASYNC_INVOKE_STATUS: StaticSchema = ( + 14, + n0, + _AIS, + 0, + (_IP, _COMPLETED, _FAILED), + ((-1, 0), (-1, 0), (-1, 0)), +) + +GET_ASYNC_INVOKE_OUTPUT: StaticSchema = ( + 18, + n0, + _GAIO, + {_sSI: _cGAIRo}, + (_iA, _mA, _cRT, _st, _fM, _sT, _lMT, _eT, _oDC), + ( + (INVOCATION_ARN, 1), + (ASYNC_INVOKE_ARN, 1), + (ASYNC_INVOKE_IDEMPOTENCY_TOKEN, 0), + (ASYNC_INVOKE_STATUS, 1), + (ASYNC_INVOKE_MESSAGE, 0), + (TIMESTAMP, 1), + (TIMESTAMP, 0), + (TIMESTAMP, 0), + (ASYNC_INVOKE_OUTPUT_DATA_CONFIG, 1), + ), ) -from smithy_core.schemas import Schema -from smithy_core.shapes import ShapeID, ShapeType -from smithy_core.traits import Trait - -NON_BLANK_STRING = Schema( - id=ShapeID("com.amazonaws.bedrockruntime#NonBlankString"), - shape_type=ShapeType.STRING, +INTERNAL_SERVER_EXCEPTION: StaticSchema = ( + 18, + n0, + _ISE, + {_s: _se, _sE: 500}, + (_m,), + ((NON_BLANK_STRING, 0),), +) + +THROTTLING_EXCEPTION: StaticSchema = ( + 18, + n0, + _TE, + {_s: _c, _sE: 429}, + (_m,), + ((NON_BLANK_STRING, 0),), +) + +VALIDATION_EXCEPTION: StaticSchema = ( + 18, + n0, + _VE, + {_s: _c, _sE: 400}, + (_m,), + ((NON_BLANK_STRING, 0),), +) + +GET_ASYNC_INVOKE: StaticOperationSchema = ( + 23, + n0, + _GAI, + { + _smit: MappingProxyType( + {"code": 200, "method": "GET", "uri": "/async-invoke/{invocationArn}"} + ) + }, + GET_ASYNC_INVOKE_INPUT, + GET_ASYNC_INVOKE_OUTPUT, + ( + ACCESS_DENIED_EXCEPTION, + INTERNAL_SERVER_EXCEPTION, + THROTTLING_EXCEPTION, + VALIDATION_EXCEPTION, + ), ) -ACCESS_DENIED_EXCEPTION = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#AccessDeniedException"), - traits=[ - Trait.new(id=ShapeID("smithy.api#error"), value="client"), - Trait.new(id=ShapeID("smithy.api#httpError"), value=403), - ], - members={"message": {"target": NON_BLANK_STRING}}, -) +MAX_RESULTS: StaticSchema = (7, n0, _MR, 0) -ACCOUNT_ID = Schema( - id=ShapeID("com.amazonaws.bedrockruntime#AccountId"), shape_type=ShapeType.STRING -) +PAGINATION_TOKEN: StaticSchema = (3, n0, _PT, 0) -ADDITIONAL_MODEL_RESPONSE_FIELD_PATHS = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#AdditionalModelResponseFieldPaths"), - shape_type=ShapeType.LIST, - members={"member": {"target": STRING}}, -) +SORT_ASYNC_INVOCATION_BY: StaticSchema = (14, n0, _SAIB, 0, (_ST,), ((-1, 0),)) -INVOCATION_ARN = Schema( - id=ShapeID("com.amazonaws.bedrockruntime#InvocationArn"), - shape_type=ShapeType.STRING, +SORT_ORDER: StaticSchema = ( + 14, + n0, + _SO, + 0, + (_ASCENDING, _DESCENDING), + ((-1, 0), (-1, 0)), ) -GET_ASYNC_INVOKE_INPUT = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#GetAsyncInvokeInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="com.amazonaws.bedrockruntime#GetAsyncInvokeRequest", - ) - ], - members={ - "invocationArn": { - "target": INVOCATION_ARN, - "traits": [ - Trait.new(id=ShapeID("smithy.api#required")), - Trait.new(id=ShapeID("smithy.api#httpLabel")), - ], - } - }, +LIST_ASYNC_INVOKES_INPUT: StaticSchema = ( + 18, + n0, + _LAII, + {_sSI: _cLAIR}, + (_sTA, _sTB, _sEt, _mR, _nT, _sB, _sO), + ( + (TIMESTAMP, {_sQ: _sTA}), + (TIMESTAMP, {_sQ: _sTB}), + (ASYNC_INVOKE_STATUS, {_sQ: _sEt}), + (MAX_RESULTS, {_sQ: _mR}), + (PAGINATION_TOKEN, {_sQ: _nT}), + (SORT_ASYNC_INVOCATION_BY, {_smith: _STu, _sQ: _sB}), + (SORT_ORDER, {_smith: _D, _sQ: _sO}), + ), ) -ASYNC_INVOKE_IDEMPOTENCY_TOKEN = Schema( - id=ShapeID("com.amazonaws.bedrockruntime#AsyncInvokeIdempotencyToken"), - shape_type=ShapeType.STRING, +ASYNC_INVOKE_SUMMARY: StaticSchema = ( + 18, + n0, + _AISs, + 0, + (_iA, _mA, _cRT, _st, _fM, _sT, _lMT, _eT, _oDC), + ( + (INVOCATION_ARN, 1), + (ASYNC_INVOKE_ARN, 1), + (ASYNC_INVOKE_IDEMPOTENCY_TOKEN, 0), + (ASYNC_INVOKE_STATUS, 0), + (ASYNC_INVOKE_MESSAGE, 0), + (TIMESTAMP, 1), + (TIMESTAMP, 0), + (TIMESTAMP, 0), + (ASYNC_INVOKE_OUTPUT_DATA_CONFIG, 1), + ), ) -TIMESTAMP = Schema( - id=ShapeID("com.amazonaws.bedrockruntime#Timestamp"), - shape_type=ShapeType.TIMESTAMP, - traits=[Trait.new(id=ShapeID("smithy.api#timestampFormat"), value="date-time")], +ASYNC_INVOKE_SUMMARIES: StaticSchema = ( + 16, + n0, + _AISsy, + 0, + (_me,), + ((ASYNC_INVOKE_SUMMARY, 0),), +) + +LIST_ASYNC_INVOKES_OUTPUT: StaticSchema = ( + 18, + n0, + _LAIO, + {_sSI: _cLAIRo}, + (_nT, _aIS), + ((PAGINATION_TOKEN, 0), (ASYNC_INVOKE_SUMMARIES, 0)), +) + +LIST_ASYNC_INVOKES: StaticOperationSchema = ( + 23, + n0, + _LAI, + {_smit: MappingProxyType({"code": 200, "method": "GET", "uri": "/async-invoke"})}, + LIST_ASYNC_INVOKES_INPUT, + LIST_ASYNC_INVOKES_OUTPUT, + ( + ACCESS_DENIED_EXCEPTION, + INTERNAL_SERVER_EXCEPTION, + THROTTLING_EXCEPTION, + VALIDATION_EXCEPTION, + ), ) -ASYNC_INVOKE_MESSAGE = Schema( - id=ShapeID("com.amazonaws.bedrockruntime#AsyncInvokeMessage"), - shape_type=ShapeType.STRING, - traits=[Trait.new(id=ShapeID("smithy.api#sensitive"))], +CONFLICT_EXCEPTION: StaticSchema = ( + 18, + n0, + _CE, + {_s: _c, _sE: 400}, + (_m,), + ((NON_BLANK_STRING, 0),), ) -ASYNC_INVOKE_ARN = Schema( - id=ShapeID("com.amazonaws.bedrockruntime#AsyncInvokeArn"), - shape_type=ShapeType.STRING, +RESOURCE_NOT_FOUND_EXCEPTION: StaticSchema = ( + 18, + n0, + _RNFE, + {_s: _c, _sE: 404}, + (_m,), + ((NON_BLANK_STRING, 0),), ) -KMS_KEY_ID = Schema( - id=ShapeID("com.amazonaws.bedrockruntime#KmsKeyId"), shape_type=ShapeType.STRING +SERVICE_QUOTA_EXCEEDED_EXCEPTION: StaticSchema = ( + 18, + n0, + _SQEE, + {_s: _c, _sE: 400}, + (_m,), + ((NON_BLANK_STRING, 0),), ) -S3_URI = Schema( - id=ShapeID("com.amazonaws.bedrockruntime#S3Uri"), shape_type=ShapeType.STRING +SERVICE_UNAVAILABLE_EXCEPTION: StaticSchema = ( + 18, + n0, + _SUE, + {_s: _se, _sE: 503}, + (_m,), + ((NON_BLANK_STRING, 0),), ) -ASYNC_INVOKE_S3_OUTPUT_DATA_CONFIG = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#AsyncInvokeS3OutputDataConfig"), - members={ - "s3Uri": { - "target": S3_URI, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - "kmsKeyId": {"target": KMS_KEY_ID}, - "bucketOwner": {"target": ACCOUNT_ID}, - }, -) +ASYNC_INVOKE_IDENTIFIER: StaticSchema = (3, n0, _AII, 0) -ASYNC_INVOKE_OUTPUT_DATA_CONFIG = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#AsyncInvokeOutputDataConfig"), - shape_type=ShapeType.UNION, - members={"s3OutputDataConfig": {"target": ASYNC_INVOKE_S3_OUTPUT_DATA_CONFIG}}, -) +MODEL_INPUT_PAYLOAD: StaticSchema = (13, n0, _MIP, 4) -ASYNC_INVOKE_STATUS = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#AsyncInvokeStatus"), - shape_type=ShapeType.ENUM, - members={ - "IN_PROGRESS": {"target": UNIT}, - "COMPLETED": {"target": UNIT}, - "FAILED": {"target": UNIT}, - }, -) +TAG_KEY: StaticSchema = (3, n0, _TK, 0) -GET_ASYNC_INVOKE_OUTPUT = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#GetAsyncInvokeOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="com.amazonaws.bedrockruntime#GetAsyncInvokeResponse", - ) - ], - members={ - "invocationArn": { - "target": INVOCATION_ARN, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - "modelArn": { - "target": ASYNC_INVOKE_ARN, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - "clientRequestToken": {"target": ASYNC_INVOKE_IDEMPOTENCY_TOKEN}, - "status": { - "target": ASYNC_INVOKE_STATUS, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - "failureMessage": {"target": ASYNC_INVOKE_MESSAGE}, - "submitTime": { - "target": TIMESTAMP, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - "lastModifiedTime": {"target": TIMESTAMP}, - "endTime": {"target": TIMESTAMP}, - "outputDataConfig": { - "target": ASYNC_INVOKE_OUTPUT_DATA_CONFIG, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - }, -) +TAG_VALUE: StaticSchema = (3, n0, _TV, 0) -INTERNAL_SERVER_EXCEPTION = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#InternalServerException"), - traits=[ - Trait.new(id=ShapeID("smithy.api#error"), value="server"), - Trait.new(id=ShapeID("smithy.api#httpError"), value=500), - ], - members={"message": {"target": NON_BLANK_STRING}}, -) - -THROTTLING_EXCEPTION = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#ThrottlingException"), - traits=[ - Trait.new(id=ShapeID("smithy.api#error"), value="client"), - Trait.new(id=ShapeID("smithy.api#httpError"), value=429), - ], - members={"message": {"target": NON_BLANK_STRING}}, -) - -VALIDATION_EXCEPTION = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#ValidationException"), - traits=[ - Trait.new(id=ShapeID("smithy.api#error"), value="client"), - Trait.new(id=ShapeID("smithy.api#httpError"), value=400), - ], - members={"message": {"target": NON_BLANK_STRING}}, -) - -GET_ASYNC_INVOKE = Schema( - id=ShapeID("com.amazonaws.bedrockruntime#GetAsyncInvoke"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType( - {"code": 200, "method": "GET", "uri": "/async-invoke/{invocationArn}"} - ), - ) - ], -) +TAG: StaticSchema = (18, n0, _Ta, 0, (_k, _v), ((TAG_KEY, 1), (TAG_VALUE, 1))) -MAX_RESULTS = Schema( - id=ShapeID("com.amazonaws.bedrockruntime#MaxResults"), shape_type=ShapeType.INTEGER -) +TAG_LIST: StaticSchema = (16, n0, _TL, 0, (_me,), ((TAG, 0),)) -PAGINATION_TOKEN = Schema( - id=ShapeID("com.amazonaws.bedrockruntime#PaginationToken"), - shape_type=ShapeType.STRING, +START_ASYNC_INVOKE_INPUT: StaticSchema = ( + 18, + n0, + _SAII, + {_sSI: _cSAIR}, + (_cRT, _mI, _mIo, _oDC, _t), + ( + (ASYNC_INVOKE_IDEMPOTENCY_TOKEN, 2), + (ASYNC_INVOKE_IDENTIFIER, 1), + (MODEL_INPUT_PAYLOAD, 1), + (ASYNC_INVOKE_OUTPUT_DATA_CONFIG, 1), + (TAG_LIST, 0), + ), ) -SORT_ASYNC_INVOCATION_BY = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#SortAsyncInvocationBy"), - shape_type=ShapeType.ENUM, - members={"SUBMISSION_TIME": {"target": UNIT}}, +START_ASYNC_INVOKE_OUTPUT: StaticSchema = ( + 18, + n0, + _SAIO, + {_sSI: _cSAIRo}, + (_iA,), + ((INVOCATION_ARN, 1),), +) + +START_ASYNC_INVOKE: StaticOperationSchema = ( + 23, + n0, + _SAI, + {_smit: MappingProxyType({"code": 200, "method": "POST", "uri": "/async-invoke"})}, + START_ASYNC_INVOKE_INPUT, + START_ASYNC_INVOKE_OUTPUT, + ( + ACCESS_DENIED_EXCEPTION, + CONFLICT_EXCEPTION, + INTERNAL_SERVER_EXCEPTION, + RESOURCE_NOT_FOUND_EXCEPTION, + SERVICE_QUOTA_EXCEEDED_EXCEPTION, + SERVICE_UNAVAILABLE_EXCEPTION, + THROTTLING_EXCEPTION, + VALIDATION_EXCEPTION, + ), ) -SORT_ORDER = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#SortOrder"), - shape_type=ShapeType.ENUM, - members={"ASCENDING": {"target": UNIT}, "DESCENDING": {"target": UNIT}}, +GUARDRAIL_IMAGE_FORMAT: StaticSchema = ( + 14, + n0, + _GIF, + 0, + (_PNG, _JPEG), + ((-1, 0), (-1, 0)), +) + +GUARDRAIL_IMAGE_SOURCE: StaticSchema = (19, n0, _GIS, 4, (_b,), ((1, 0),)) + +GUARDRAIL_IMAGE_BLOCK: StaticSchema = ( + 18, + n0, + _GIB, + 4, + (_f, _so), + ((GUARDRAIL_IMAGE_FORMAT, 1), (GUARDRAIL_IMAGE_SOURCE, 1)), +) + +GUARDRAIL_CONTENT_QUALIFIER: StaticSchema = ( + 14, + n0, + _GCQ, + 0, + (_GS, _QUERY, _GC), + ((-1, 0), (-1, 0), (-1, 0)), +) + +GUARDRAIL_CONTENT_QUALIFIER_LIST: StaticSchema = ( + 16, + n0, + _GCQL, + 0, + (_me,), + ((GUARDRAIL_CONTENT_QUALIFIER, 0),), +) + +GUARDRAIL_TEXT_BLOCK: StaticSchema = ( + 18, + n0, + _GTB, + 0, + (_te, _q), + ((3, 1), (GUARDRAIL_CONTENT_QUALIFIER_LIST, 0)), +) + +GUARDRAIL_CONTENT_BLOCK: StaticSchema = ( + 19, + n0, + _GCB, + 0, + (_te, _i), + ((GUARDRAIL_TEXT_BLOCK, 0), (GUARDRAIL_IMAGE_BLOCK, 0)), +) + +GUARDRAIL_CONTENT_BLOCK_LIST: StaticSchema = ( + 16, + n0, + _GCBL, + 0, + (_me,), + ((GUARDRAIL_CONTENT_BLOCK, 0),), +) + +GUARDRAIL_IDENTIFIER: StaticSchema = (3, n0, _GI, 0) + +GUARDRAIL_VERSION: StaticSchema = (3, n0, _GV, 0) + +GUARDRAIL_OUTPUT_SCOPE: StaticSchema = ( + 14, + n0, + _GOS, + 0, + (_INTERVENTIONS, _FULL), + ((-1, 0), (-1, 0)), +) + +GUARDRAIL_CONTENT_SOURCE: StaticSchema = ( + 14, + n0, + _GCS, + 0, + (_INPUT, _OUTPUT), + ((-1, 0), (-1, 0)), +) + +APPLY_GUARDRAIL_INPUT: StaticSchema = ( + 18, + n0, + _AGI, + {_sSI: _cAGR}, + (_gI, _gV, _so, _co, _oS), + ( + (GUARDRAIL_IDENTIFIER, 9), + (GUARDRAIL_VERSION, 9), + (GUARDRAIL_CONTENT_SOURCE, 1), + (GUARDRAIL_CONTENT_BLOCK_LIST, 1), + (GUARDRAIL_OUTPUT_SCOPE, 0), + ), ) -LIST_ASYNC_INVOKES_INPUT = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#ListAsyncInvokesInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="com.amazonaws.bedrockruntime#ListAsyncInvokesRequest", - ) - ], - members={ - "submitTimeAfter": { - "target": TIMESTAMP, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpQuery"), value="submitTimeAfter") - ], - }, - "submitTimeBefore": { - "target": TIMESTAMP, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpQuery"), value="submitTimeBefore") - ], - }, - "statusEquals": { - "target": ASYNC_INVOKE_STATUS, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpQuery"), value="statusEquals") - ], - }, - "maxResults": { - "target": MAX_RESULTS, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpQuery"), value="maxResults") - ], - }, - "nextToken": { - "target": PAGINATION_TOKEN, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpQuery"), value="nextToken") - ], - }, - "sortBy": { - "target": SORT_ASYNC_INVOCATION_BY, - "traits": [ - Trait.new(id=ShapeID("smithy.api#default"), value="SubmissionTime"), - Trait.new(id=ShapeID("smithy.api#httpQuery"), value="sortBy"), - ], - }, - "sortOrder": { - "target": SORT_ORDER, - "traits": [ - Trait.new(id=ShapeID("smithy.api#default"), value="Descending"), - Trait.new(id=ShapeID("smithy.api#httpQuery"), value="sortOrder"), - ], - }, - }, -) +GUARDRAIL_ACTION: StaticSchema = (14, n0, _GA, 0, (_NONE, _GI_), ((-1, 0), (-1, 0))) -ASYNC_INVOKE_SUMMARY = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#AsyncInvokeSummary"), - members={ - "invocationArn": { - "target": INVOCATION_ARN, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - "modelArn": { - "target": ASYNC_INVOKE_ARN, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - "clientRequestToken": {"target": ASYNC_INVOKE_IDEMPOTENCY_TOKEN}, - "status": {"target": ASYNC_INVOKE_STATUS}, - "failureMessage": {"target": ASYNC_INVOKE_MESSAGE}, - "submitTime": { - "target": TIMESTAMP, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - "lastModifiedTime": {"target": TIMESTAMP}, - "endTime": {"target": TIMESTAMP}, - "outputDataConfig": { - "target": ASYNC_INVOKE_OUTPUT_DATA_CONFIG, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - }, -) +GUARDRAIL_ARN: StaticSchema = (3, n0, _GAu, 0) -ASYNC_INVOKE_SUMMARIES = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#AsyncInvokeSummaries"), - shape_type=ShapeType.LIST, - members={"member": {"target": ASYNC_INVOKE_SUMMARY}}, -) +GUARDRAIL_ID: StaticSchema = (3, n0, _GIu, 0) -LIST_ASYNC_INVOKES_OUTPUT = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#ListAsyncInvokesOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="com.amazonaws.bedrockruntime#ListAsyncInvokesResponse", - ) - ], - members={ - "nextToken": {"target": PAGINATION_TOKEN}, - "asyncInvokeSummaries": {"target": ASYNC_INVOKE_SUMMARIES}, - }, +GUARDRAIL_ORIGIN: StaticSchema = ( + 14, + n0, + _GO, + 0, + (_REQUEST, _AE, _OE), + ((-1, 0), (-1, 0), (-1, 0)), ) -LIST_ASYNC_INVOKES = Schema( - id=ShapeID("com.amazonaws.bedrockruntime#ListAsyncInvokes"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType( - {"code": 200, "method": "GET", "uri": "/async-invoke"} - ), - ) - ], +GUARDRAIL_ORIGIN_LIST: StaticSchema = ( + 16, + n0, + _GOL, + 0, + (_me,), + ((GUARDRAIL_ORIGIN, 0),), ) -CONFLICT_EXCEPTION = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#ConflictException"), - traits=[ - Trait.new(id=ShapeID("smithy.api#error"), value="client"), - Trait.new(id=ShapeID("smithy.api#httpError"), value=400), - ], - members={"message": {"target": NON_BLANK_STRING}}, -) +GUARDRAIL_OWNERSHIP: StaticSchema = (14, n0, _GOu, 0, (_SELF, _CA), ((-1, 0), (-1, 0))) -RESOURCE_NOT_FOUND_EXCEPTION = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#ResourceNotFoundException"), - traits=[ - Trait.new(id=ShapeID("smithy.api#error"), value="client"), - Trait.new(id=ShapeID("smithy.api#httpError"), value=404), - ], - members={"message": {"target": NON_BLANK_STRING}}, +APPLIED_GUARDRAIL_DETAILS: StaticSchema = ( + 18, + n0, + _AGD, + 0, + (_gIu, _gV, _gA, _gO, _gOu), + ( + (GUARDRAIL_ID, 0), + (GUARDRAIL_VERSION, 0), + (GUARDRAIL_ARN, 0), + (GUARDRAIL_ORIGIN_LIST, 0), + (GUARDRAIL_OWNERSHIP, 0), + ), ) -SERVICE_QUOTA_EXCEEDED_EXCEPTION = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#ServiceQuotaExceededException"), - traits=[ - Trait.new(id=ShapeID("smithy.api#error"), value="client"), - Trait.new(id=ShapeID("smithy.api#httpError"), value=400), - ], - members={"message": {"target": NON_BLANK_STRING}}, -) +AUTOMATED_REASONING_RULE_IDENTIFIER: StaticSchema = (3, n0, _ARRI, 0) -SERVICE_UNAVAILABLE_EXCEPTION = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#ServiceUnavailableException"), - traits=[ - Trait.new(id=ShapeID("smithy.api#error"), value="server"), - Trait.new(id=ShapeID("smithy.api#httpError"), value=503), - ], - members={"message": {"target": NON_BLANK_STRING}}, -) +GUARDRAIL_AUTOMATED_REASONING_POLICY_VERSION_ARN: StaticSchema = (3, n0, _GARPVA, 0) -ASYNC_INVOKE_IDENTIFIER = Schema( - id=ShapeID("com.amazonaws.bedrockruntime#AsyncInvokeIdentifier"), - shape_type=ShapeType.STRING, +GUARDRAIL_AUTOMATED_REASONING_RULE: StaticSchema = ( + 18, + n0, + _GARR, + 0, + (_id, _pVA), + ( + (AUTOMATED_REASONING_RULE_IDENTIFIER, 0), + (GUARDRAIL_AUTOMATED_REASONING_POLICY_VERSION_ARN, 0), + ), ) -MODEL_INPUT_PAYLOAD = Schema( - id=ShapeID("com.amazonaws.bedrockruntime#ModelInputPayload"), - shape_type=ShapeType.DOCUMENT, - traits=[Trait.new(id=ShapeID("smithy.api#sensitive"))], +GUARDRAIL_AUTOMATED_REASONING_RULE_LIST: StaticSchema = ( + 16, + n0, + _GARRL, + 0, + (_me,), + ((GUARDRAIL_AUTOMATED_REASONING_RULE, 0),), ) -TAG_KEY = Schema( - id=ShapeID("com.amazonaws.bedrockruntime#TagKey"), shape_type=ShapeType.STRING +GUARDRAIL_AUTOMATED_REASONING_STATEMENT_LOGIC_CONTENT: StaticSchema = ( + 3, + n0, + _GARSLC, + 4, ) -TAG_VALUE = Schema( - id=ShapeID("com.amazonaws.bedrockruntime#TagValue"), shape_type=ShapeType.STRING +GUARDRAIL_AUTOMATED_REASONING_STATEMENT_NATURAL_LANGUAGE_CONTENT: StaticSchema = ( + 3, + n0, + _GARSNLC, + 4, ) -TAG = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#Tag"), - members={ - "key": { - "target": TAG_KEY, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - "value": { - "target": TAG_VALUE, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - }, +GUARDRAIL_AUTOMATED_REASONING_STATEMENT: StaticSchema = ( + 18, + n0, + _GARS, + 0, + (_l, _nL), + ( + (GUARDRAIL_AUTOMATED_REASONING_STATEMENT_LOGIC_CONTENT, 0), + (GUARDRAIL_AUTOMATED_REASONING_STATEMENT_NATURAL_LANGUAGE_CONTENT, 0), + ), ) -TAG_LIST = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#TagList"), - shape_type=ShapeType.LIST, - members={"member": {"target": TAG}}, +GUARDRAIL_AUTOMATED_REASONING_STATEMENT_LIST: StaticSchema = ( + 16, + n0, + _GARSL, + 0, + (_me,), + ((GUARDRAIL_AUTOMATED_REASONING_STATEMENT, 0),), +) + +GUARDRAIL_AUTOMATED_REASONING_LOGIC_WARNING_TYPE: StaticSchema = ( + 14, + n0, + _GARLWT, + 0, + (_AF, _AT), + ((-1, 0), (-1, 0)), +) + +GUARDRAIL_AUTOMATED_REASONING_LOGIC_WARNING: StaticSchema = ( + 18, + n0, + _GARLW, + 0, + (_ty, _p, _cl), + ( + (GUARDRAIL_AUTOMATED_REASONING_LOGIC_WARNING_TYPE, 0), + (GUARDRAIL_AUTOMATED_REASONING_STATEMENT_LIST, 0), + (GUARDRAIL_AUTOMATED_REASONING_STATEMENT_LIST, 0), + ), ) -START_ASYNC_INVOKE_INPUT = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#StartAsyncInvokeInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="com.amazonaws.bedrockruntime#StartAsyncInvokeRequest", - ) - ], - members={ - "clientRequestToken": { - "target": ASYNC_INVOKE_IDEMPOTENCY_TOKEN, - "traits": [Trait.new(id=ShapeID("smithy.api#idempotencyToken"))], - }, - "modelId": { - "target": ASYNC_INVOKE_IDENTIFIER, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - "modelInput": { - "target": MODEL_INPUT_PAYLOAD, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - "outputDataConfig": { - "target": ASYNC_INVOKE_OUTPUT_DATA_CONFIG, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - "tags": {"target": TAG_LIST}, - }, +GUARDRAIL_AUTOMATED_REASONING_TRANSLATION_CONFIDENCE: StaticSchema = (10, n0, _GARTC, 0) + +GUARDRAIL_AUTOMATED_REASONING_INPUT_TEXT_REFERENCE: StaticSchema = ( + 18, + n0, + _GARITR, + 0, + (_te,), + ((GUARDRAIL_AUTOMATED_REASONING_STATEMENT_NATURAL_LANGUAGE_CONTENT, 0),), +) + +GUARDRAIL_AUTOMATED_REASONING_INPUT_TEXT_REFERENCE_LIST: StaticSchema = ( + 16, + n0, + _GARITRL, + 0, + (_me,), + ((GUARDRAIL_AUTOMATED_REASONING_INPUT_TEXT_REFERENCE, 0),), +) + +GUARDRAIL_AUTOMATED_REASONING_TRANSLATION: StaticSchema = ( + 18, + n0, + _GART, + 0, + (_p, _cl, _uP, _uC, _con), + ( + (GUARDRAIL_AUTOMATED_REASONING_STATEMENT_LIST, 0), + (GUARDRAIL_AUTOMATED_REASONING_STATEMENT_LIST, 0), + (GUARDRAIL_AUTOMATED_REASONING_INPUT_TEXT_REFERENCE_LIST, 0), + (GUARDRAIL_AUTOMATED_REASONING_INPUT_TEXT_REFERENCE_LIST, 0), + (GUARDRAIL_AUTOMATED_REASONING_TRANSLATION_CONFIDENCE, 0), + ), ) -START_ASYNC_INVOKE_OUTPUT = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#StartAsyncInvokeOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="com.amazonaws.bedrockruntime#StartAsyncInvokeResponse", - ) - ], - members={ - "invocationArn": { - "target": INVOCATION_ARN, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - } - }, +GUARDRAIL_AUTOMATED_REASONING_IMPOSSIBLE_FINDING: StaticSchema = ( + 18, + n0, + _GARIF, + 0, + (_tr, _cR, _lW), + ( + (GUARDRAIL_AUTOMATED_REASONING_TRANSLATION, 0), + (GUARDRAIL_AUTOMATED_REASONING_RULE_LIST, 0), + (GUARDRAIL_AUTOMATED_REASONING_LOGIC_WARNING, 0), + ), ) -START_ASYNC_INVOKE = Schema( - id=ShapeID("com.amazonaws.bedrockruntime#StartAsyncInvoke"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType( - {"code": 200, "method": "POST", "uri": "/async-invoke"} - ), - ) - ], -) - -GUARDRAIL_IMAGE_FORMAT = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#GuardrailImageFormat"), - shape_type=ShapeType.ENUM, - members={"PNG": {"target": UNIT}, "JPEG": {"target": UNIT}}, -) - -GUARDRAIL_IMAGE_SOURCE = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#GuardrailImageSource"), - shape_type=ShapeType.UNION, - traits=[Trait.new(id=ShapeID("smithy.api#sensitive"))], - members={"bytes": {"target": BLOB}}, -) - -GUARDRAIL_IMAGE_BLOCK = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#GuardrailImageBlock"), - traits=[Trait.new(id=ShapeID("smithy.api#sensitive"))], - members={ - "format": { - "target": GUARDRAIL_IMAGE_FORMAT, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - "source": { - "target": GUARDRAIL_IMAGE_SOURCE, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - }, +GUARDRAIL_AUTOMATED_REASONING_INVALID_FINDING: StaticSchema = ( + 18, + n0, + _GARIFu, + 0, + (_tr, _cR, _lW), + ( + (GUARDRAIL_AUTOMATED_REASONING_TRANSLATION, 0), + (GUARDRAIL_AUTOMATED_REASONING_RULE_LIST, 0), + (GUARDRAIL_AUTOMATED_REASONING_LOGIC_WARNING, 0), + ), ) -GUARDRAIL_CONTENT_QUALIFIER = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#GuardrailContentQualifier"), - shape_type=ShapeType.ENUM, - members={ - "GROUNDING_SOURCE": {"target": UNIT}, - "QUERY": {"target": UNIT}, - "GUARD_CONTENT": {"target": UNIT}, - }, +GUARDRAIL_AUTOMATED_REASONING_NO_TRANSLATIONS_FINDING: StaticSchema = ( + 18, + n0, + _GARNTF, + 0, +) + +GUARDRAIL_AUTOMATED_REASONING_SCENARIO: StaticSchema = ( + 18, + n0, + _GARSu, + 0, + (_sta,), + ((GUARDRAIL_AUTOMATED_REASONING_STATEMENT_LIST, 0),), +) + +GUARDRAIL_AUTOMATED_REASONING_SATISFIABLE_FINDING: StaticSchema = ( + 18, + n0, + _GARSF, + 0, + (_tr, _cTS, _cFS, _lW), + ( + (GUARDRAIL_AUTOMATED_REASONING_TRANSLATION, 0), + (GUARDRAIL_AUTOMATED_REASONING_SCENARIO, 0), + (GUARDRAIL_AUTOMATED_REASONING_SCENARIO, 0), + (GUARDRAIL_AUTOMATED_REASONING_LOGIC_WARNING, 0), + ), ) -GUARDRAIL_CONTENT_QUALIFIER_LIST = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#GuardrailContentQualifierList"), - shape_type=ShapeType.LIST, - members={"member": {"target": GUARDRAIL_CONTENT_QUALIFIER}}, +GUARDRAIL_AUTOMATED_REASONING_TOO_COMPLEX_FINDING: StaticSchema = (18, n0, _GARTCF, 0) + +GUARDRAIL_AUTOMATED_REASONING_DIFFERENCE_SCENARIO_LIST: StaticSchema = ( + 16, + n0, + _GARDSL, + 0, + (_me,), + ((GUARDRAIL_AUTOMATED_REASONING_SCENARIO, 0),), +) + +GUARDRAIL_AUTOMATED_REASONING_TRANSLATION_LIST: StaticSchema = ( + 16, + n0, + _GARTL, + 0, + (_me,), + ((GUARDRAIL_AUTOMATED_REASONING_TRANSLATION, 0),), +) + +GUARDRAIL_AUTOMATED_REASONING_TRANSLATION_OPTION: StaticSchema = ( + 18, + n0, + _GARTO, + 0, + (_tra,), + ((GUARDRAIL_AUTOMATED_REASONING_TRANSLATION_LIST, 0),), +) + +GUARDRAIL_AUTOMATED_REASONING_TRANSLATION_OPTION_LIST: StaticSchema = ( + 16, + n0, + _GARTOL, + 0, + (_me,), + ((GUARDRAIL_AUTOMATED_REASONING_TRANSLATION_OPTION, 0),), +) + +GUARDRAIL_AUTOMATED_REASONING_TRANSLATION_AMBIGUOUS_FINDING: StaticSchema = ( + 18, + n0, + _GARTAF, + 0, + (_o, _dS), + ( + (GUARDRAIL_AUTOMATED_REASONING_TRANSLATION_OPTION_LIST, 0), + (GUARDRAIL_AUTOMATED_REASONING_DIFFERENCE_SCENARIO_LIST, 0), + ), ) -GUARDRAIL_TEXT_BLOCK = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#GuardrailTextBlock"), - members={ - "text": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - "qualifiers": {"target": GUARDRAIL_CONTENT_QUALIFIER_LIST}, - }, +GUARDRAIL_AUTOMATED_REASONING_VALID_FINDING: StaticSchema = ( + 18, + n0, + _GARVF, + 0, + (_tr, _cTS, _sR, _lW), + ( + (GUARDRAIL_AUTOMATED_REASONING_TRANSLATION, 0), + (GUARDRAIL_AUTOMATED_REASONING_SCENARIO, 0), + (GUARDRAIL_AUTOMATED_REASONING_RULE_LIST, 0), + (GUARDRAIL_AUTOMATED_REASONING_LOGIC_WARNING, 0), + ), ) -GUARDRAIL_CONTENT_BLOCK = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#GuardrailContentBlock"), - shape_type=ShapeType.UNION, - members={ - "text": {"target": GUARDRAIL_TEXT_BLOCK}, - "image": {"target": GUARDRAIL_IMAGE_BLOCK}, - }, +GUARDRAIL_AUTOMATED_REASONING_FINDING: StaticSchema = ( + 19, + n0, + _GARF, + 0, + (_va, _in, _sa, _im, _tA, _tC, _nTo), + ( + (GUARDRAIL_AUTOMATED_REASONING_VALID_FINDING, 0), + (GUARDRAIL_AUTOMATED_REASONING_INVALID_FINDING, 0), + (GUARDRAIL_AUTOMATED_REASONING_SATISFIABLE_FINDING, 0), + (GUARDRAIL_AUTOMATED_REASONING_IMPOSSIBLE_FINDING, 0), + (GUARDRAIL_AUTOMATED_REASONING_TRANSLATION_AMBIGUOUS_FINDING, 0), + (GUARDRAIL_AUTOMATED_REASONING_TOO_COMPLEX_FINDING, 0), + (GUARDRAIL_AUTOMATED_REASONING_NO_TRANSLATIONS_FINDING, 0), + ), ) -GUARDRAIL_CONTENT_BLOCK_LIST = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#GuardrailContentBlockList"), - shape_type=ShapeType.LIST, - members={"member": {"target": GUARDRAIL_CONTENT_BLOCK}}, +GUARDRAIL_AUTOMATED_REASONING_FINDING_LIST: StaticSchema = ( + 16, + n0, + _GARFL, + 0, + (_me,), + ((GUARDRAIL_AUTOMATED_REASONING_FINDING, 0),), +) + +GUARDRAIL_AUTOMATED_REASONING_POLICY_ASSESSMENT: StaticSchema = ( + 18, + n0, + _GARPA, + 0, + (_fi,), + ((GUARDRAIL_AUTOMATED_REASONING_FINDING_LIST, 0),), +) + +GUARDRAIL_CONTENT_POLICY_ACTION: StaticSchema = ( + 14, + n0, + _GCPA, + 0, + (_BLOCKED, _NONE), + ((-1, 0), (-1, 0)), +) + +GUARDRAIL_CONTENT_FILTER_CONFIDENCE: StaticSchema = ( + 14, + n0, + _GCFC, + 0, + (_NONE, _LOW, _MEDIUM, _HIGH), + ((-1, 0), (-1, 0), (-1, 0), (-1, 0)), +) + +GUARDRAIL_CONTENT_FILTER_STRENGTH: StaticSchema = ( + 14, + n0, + _GCFS, + 0, + (_NONE, _LOW, _MEDIUM, _HIGH), + ((-1, 0), (-1, 0), (-1, 0), (-1, 0)), +) + +GUARDRAIL_CONTENT_FILTER_TYPE: StaticSchema = ( + 14, + n0, + _GCFT, + 0, + (_INSULTS, _HATE, _SEXUAL, _VIOLENCE, _MISCONDUCT, _PA), + ((-1, 0), (-1, 0), (-1, 0), (-1, 0), (-1, 0), (-1, 0)), +) + +GUARDRAIL_CONTENT_FILTER: StaticSchema = ( + 18, + n0, + _GCF, + 0, + (_ty, _con, _fS, _a, _d), + ( + (GUARDRAIL_CONTENT_FILTER_TYPE, 1), + (GUARDRAIL_CONTENT_FILTER_CONFIDENCE, 1), + (GUARDRAIL_CONTENT_FILTER_STRENGTH, 0), + (GUARDRAIL_CONTENT_POLICY_ACTION, 1), + (2, 0), + ), ) -GUARDRAIL_IDENTIFIER = Schema( - id=ShapeID("com.amazonaws.bedrockruntime#GuardrailIdentifier"), - shape_type=ShapeType.STRING, +GUARDRAIL_CONTENT_FILTER_LIST: StaticSchema = ( + 16, + n0, + _GCFL, + 0, + (_me,), + ((GUARDRAIL_CONTENT_FILTER, 0),), +) + +GUARDRAIL_CONTENT_POLICY_ASSESSMENT: StaticSchema = ( + 18, + n0, + _GCPAu, + 0, + (_fil,), + ((GUARDRAIL_CONTENT_FILTER_LIST, 1),), +) + +GUARDRAIL_CONTEXTUAL_GROUNDING_POLICY_ACTION: StaticSchema = ( + 14, + n0, + _GCGPA, + 0, + (_BLOCKED, _NONE), + ((-1, 0), (-1, 0)), +) + +GUARDRAIL_CONTEXTUAL_GROUNDING_FILTER_TYPE: StaticSchema = ( + 14, + n0, + _GCGFT, + 0, + (_GROUNDING, _RELEVANCE), + ((-1, 0), (-1, 0)), +) + +GUARDRAIL_CONTEXTUAL_GROUNDING_FILTER: StaticSchema = ( + 18, + n0, + _GCGF, + 0, + (_ty, _th, _sc, _a, _d), + ( + (GUARDRAIL_CONTEXTUAL_GROUNDING_FILTER_TYPE, 1), + (10, 1), + (10, 1), + (GUARDRAIL_CONTEXTUAL_GROUNDING_POLICY_ACTION, 1), + (2, 0), + ), ) -GUARDRAIL_VERSION = Schema( - id=ShapeID("com.amazonaws.bedrockruntime#GuardrailVersion"), - shape_type=ShapeType.STRING, +GUARDRAIL_CONTEXTUAL_GROUNDING_FILTERS: StaticSchema = ( + 16, + n0, + _GCGFu, + 0, + (_me,), + ((GUARDRAIL_CONTEXTUAL_GROUNDING_FILTER, 0),), ) -GUARDRAIL_OUTPUT_SCOPE = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#GuardrailOutputScope"), - shape_type=ShapeType.ENUM, - members={"INTERVENTIONS": {"target": UNIT}, "FULL": {"target": UNIT}}, +GUARDRAIL_CONTEXTUAL_GROUNDING_POLICY_ASSESSMENT: StaticSchema = ( + 18, + n0, + _GCGPAu, + 0, + (_fil,), + ((GUARDRAIL_CONTEXTUAL_GROUNDING_FILTERS, 0),), ) -GUARDRAIL_CONTENT_SOURCE = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#GuardrailContentSource"), - shape_type=ShapeType.ENUM, - members={"INPUT": {"target": UNIT}, "OUTPUT": {"target": UNIT}}, -) +IMAGES_GUARDED: StaticSchema = (7, n0, _IG, 0) -APPLY_GUARDRAIL_INPUT = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#ApplyGuardrailInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="com.amazonaws.bedrockruntime#ApplyGuardrailRequest", - ) - ], - members={ - "guardrailIdentifier": { - "target": GUARDRAIL_IDENTIFIER, - "traits": [ - Trait.new(id=ShapeID("smithy.api#required")), - Trait.new(id=ShapeID("smithy.api#httpLabel")), - ], - }, - "guardrailVersion": { - "target": GUARDRAIL_VERSION, - "traits": [ - Trait.new(id=ShapeID("smithy.api#required")), - Trait.new(id=ShapeID("smithy.api#httpLabel")), - ], - }, - "source": { - "target": GUARDRAIL_CONTENT_SOURCE, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - "content": { - "target": GUARDRAIL_CONTENT_BLOCK_LIST, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - "outputScope": {"target": GUARDRAIL_OUTPUT_SCOPE}, - }, -) +IMAGES_TOTAL: StaticSchema = (7, n0, _IT, 0) -GUARDRAIL_ACTION = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#GuardrailAction"), - shape_type=ShapeType.ENUM, - members={"NONE": {"target": UNIT}, "GUARDRAIL_INTERVENED": {"target": UNIT}}, +GUARDRAIL_IMAGE_COVERAGE: StaticSchema = ( + 18, + n0, + _GIC, + 0, + (_g, _to), + ((IMAGES_GUARDED, 0), (IMAGES_TOTAL, 0)), ) -GUARDRAIL_ARN = Schema( - id=ShapeID("com.amazonaws.bedrockruntime#GuardrailArn"), shape_type=ShapeType.STRING -) +TEXT_CHARACTERS_GUARDED: StaticSchema = (7, n0, _TCG, 0) -GUARDRAIL_ID = Schema( - id=ShapeID("com.amazonaws.bedrockruntime#GuardrailId"), shape_type=ShapeType.STRING -) +TEXT_CHARACTERS_TOTAL: StaticSchema = (7, n0, _TCT, 0) -GUARDRAIL_ORIGIN = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#GuardrailOrigin"), - shape_type=ShapeType.ENUM, - members={ - "REQUEST": {"target": UNIT}, - "ACCOUNT_ENFORCED": {"target": UNIT}, - "ORGANIZATION_ENFORCED": {"target": UNIT}, - }, +GUARDRAIL_TEXT_CHARACTERS_COVERAGE: StaticSchema = ( + 18, + n0, + _GTCC, + 0, + (_g, _to), + ((TEXT_CHARACTERS_GUARDED, 0), (TEXT_CHARACTERS_TOTAL, 0)), ) -GUARDRAIL_ORIGIN_LIST = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#GuardrailOriginList"), - shape_type=ShapeType.LIST, - members={"member": {"target": GUARDRAIL_ORIGIN}}, +GUARDRAIL_COVERAGE: StaticSchema = ( + 18, + n0, + _GCu, + 0, + (_tCe, _ima), + ((GUARDRAIL_TEXT_CHARACTERS_COVERAGE, 0), (GUARDRAIL_IMAGE_COVERAGE, 0)), ) -GUARDRAIL_OWNERSHIP = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#GuardrailOwnership"), - shape_type=ShapeType.ENUM, - members={"SELF": {"target": UNIT}, "CROSS_ACCOUNT": {"target": UNIT}}, -) +GUARDRAIL_PROCESSING_LATENCY: StaticSchema = (8, n0, _GPL, 0) -APPLIED_GUARDRAIL_DETAILS = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#AppliedGuardrailDetails"), - members={ - "guardrailId": {"target": GUARDRAIL_ID}, - "guardrailVersion": {"target": GUARDRAIL_VERSION}, - "guardrailArn": {"target": GUARDRAIL_ARN}, - "guardrailOrigin": {"target": GUARDRAIL_ORIGIN_LIST}, - "guardrailOwnership": {"target": GUARDRAIL_OWNERSHIP}, - }, -) +GUARDRAIL_AUTOMATED_REASONING_POLICIES_PROCESSED: StaticSchema = (7, n0, _GARPP, 0) -AUTOMATED_REASONING_RULE_IDENTIFIER = Schema( - id=ShapeID("com.amazonaws.bedrockruntime#AutomatedReasoningRuleIdentifier"), - shape_type=ShapeType.STRING, -) +GUARDRAIL_AUTOMATED_REASONING_POLICY_UNITS_PROCESSED: StaticSchema = (7, n0, _GARPUP, 0) -GUARDRAIL_AUTOMATED_REASONING_POLICY_VERSION_ARN = Schema( - id=ShapeID( - "com.amazonaws.bedrockruntime#GuardrailAutomatedReasoningPolicyVersionArn" - ), - shape_type=ShapeType.STRING, -) +GUARDRAIL_CONTENT_POLICY_IMAGE_UNITS_PROCESSED: StaticSchema = (7, n0, _GCPIUP, 0) -GUARDRAIL_AUTOMATED_REASONING_RULE = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#GuardrailAutomatedReasoningRule"), - members={ - "identifier": {"target": AUTOMATED_REASONING_RULE_IDENTIFIER}, - "policyVersionArn": { - "target": GUARDRAIL_AUTOMATED_REASONING_POLICY_VERSION_ARN - }, - }, -) +GUARDRAIL_CONTENT_POLICY_UNITS_PROCESSED: StaticSchema = (7, n0, _GCPUP, 0) -GUARDRAIL_AUTOMATED_REASONING_RULE_LIST = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#GuardrailAutomatedReasoningRuleList"), - shape_type=ShapeType.LIST, - members={"member": {"target": GUARDRAIL_AUTOMATED_REASONING_RULE}}, +GUARDRAIL_CONTEXTUAL_GROUNDING_POLICY_UNITS_PROCESSED: StaticSchema = ( + 7, + n0, + _GCGPUP, + 0, ) -GUARDRAIL_AUTOMATED_REASONING_STATEMENT_LOGIC_CONTENT = Schema( - id=ShapeID( - "com.amazonaws.bedrockruntime#GuardrailAutomatedReasoningStatementLogicContent" - ), - shape_type=ShapeType.STRING, - traits=[Trait.new(id=ShapeID("smithy.api#sensitive"))], +GUARDRAIL_SENSITIVE_INFORMATION_POLICY_FREE_UNITS_PROCESSED: StaticSchema = ( + 7, + n0, + _GSIPFUP, + 0, ) -GUARDRAIL_AUTOMATED_REASONING_STATEMENT_NATURAL_LANGUAGE_CONTENT = Schema( - id=ShapeID( - "com.amazonaws.bedrockruntime#GuardrailAutomatedReasoningStatementNaturalLanguageContent" - ), - shape_type=ShapeType.STRING, - traits=[Trait.new(id=ShapeID("smithy.api#sensitive"))], +GUARDRAIL_SENSITIVE_INFORMATION_POLICY_UNITS_PROCESSED: StaticSchema = ( + 7, + n0, + _GSIPUP, + 0, ) -GUARDRAIL_AUTOMATED_REASONING_STATEMENT = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#GuardrailAutomatedReasoningStatement"), - members={ - "logic": {"target": GUARDRAIL_AUTOMATED_REASONING_STATEMENT_LOGIC_CONTENT}, - "naturalLanguage": { - "target": GUARDRAIL_AUTOMATED_REASONING_STATEMENT_NATURAL_LANGUAGE_CONTENT - }, - }, -) +GUARDRAIL_TOPIC_POLICY_UNITS_PROCESSED: StaticSchema = (7, n0, _GTPUP, 0) -GUARDRAIL_AUTOMATED_REASONING_STATEMENT_LIST = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#GuardrailAutomatedReasoningStatementList"), - shape_type=ShapeType.LIST, - members={"member": {"target": GUARDRAIL_AUTOMATED_REASONING_STATEMENT}}, -) +GUARDRAIL_WORD_POLICY_UNITS_PROCESSED: StaticSchema = (7, n0, _GWPUP, 0) -GUARDRAIL_AUTOMATED_REASONING_LOGIC_WARNING_TYPE = Schema.collection( - id=ShapeID( - "com.amazonaws.bedrockruntime#GuardrailAutomatedReasoningLogicWarningType" +GUARDRAIL_USAGE: StaticSchema = ( + 18, + n0, + _GU, + 0, + (_tPU, _cPU, _wPU, _sIPU, _sIPFU, _cGPU, _cPIU, _aRPU, _aRP), + ( + (GUARDRAIL_TOPIC_POLICY_UNITS_PROCESSED, 1), + (GUARDRAIL_CONTENT_POLICY_UNITS_PROCESSED, 1), + (GUARDRAIL_WORD_POLICY_UNITS_PROCESSED, 1), + (GUARDRAIL_SENSITIVE_INFORMATION_POLICY_UNITS_PROCESSED, 1), + (GUARDRAIL_SENSITIVE_INFORMATION_POLICY_FREE_UNITS_PROCESSED, 1), + (GUARDRAIL_CONTEXTUAL_GROUNDING_POLICY_UNITS_PROCESSED, 1), + (GUARDRAIL_CONTENT_POLICY_IMAGE_UNITS_PROCESSED, 0), + (GUARDRAIL_AUTOMATED_REASONING_POLICY_UNITS_PROCESSED, 0), + (GUARDRAIL_AUTOMATED_REASONING_POLICIES_PROCESSED, 0), ), - shape_type=ShapeType.ENUM, - members={"ALWAYS_FALSE": {"target": UNIT}, "ALWAYS_TRUE": {"target": UNIT}}, -) - -GUARDRAIL_AUTOMATED_REASONING_LOGIC_WARNING = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#GuardrailAutomatedReasoningLogicWarning"), - members={ - "type": {"target": GUARDRAIL_AUTOMATED_REASONING_LOGIC_WARNING_TYPE}, - "premises": {"target": GUARDRAIL_AUTOMATED_REASONING_STATEMENT_LIST}, - "claims": {"target": GUARDRAIL_AUTOMATED_REASONING_STATEMENT_LIST}, - }, ) -GUARDRAIL_AUTOMATED_REASONING_TRANSLATION_CONFIDENCE = Schema( - id=ShapeID( - "com.amazonaws.bedrockruntime#GuardrailAutomatedReasoningTranslationConfidence" +GUARDRAIL_INVOCATION_METRICS: StaticSchema = ( + 18, + n0, + _GIM, + 0, + (_gPL, _u, _gC), + ((GUARDRAIL_PROCESSING_LATENCY, 0), (GUARDRAIL_USAGE, 0), (GUARDRAIL_COVERAGE, 0)), +) + +GUARDRAIL_SENSITIVE_INFORMATION_POLICY_ACTION: StaticSchema = ( + 14, + n0, + _GSIPA, + 0, + (_ANONYMIZED, _BLOCKED, _NONE), + ((-1, 0), (-1, 0), (-1, 0)), +) + +GUARDRAIL_PII_ENTITY_TYPE: StaticSchema = ( + 14, + n0, + _GPET, + 0, + ( + _ADDRESS, + _AGE, + _AAK, + _ASK, + _CHN, + _CSIN, + _CDCC, + _CDCE, + _CDCN, + _DI, + _EMAIL, + _IBAN, + _IA_, + _LP, + _MA, + _NAME, + _PASSWORD, + _PHONE, + _PIN, + _SC, + _UNHSN, + _UNIN, + _UUTRN, + _URL, + _USERNAME, + _UBAN, + _UBRN, + _UITIN, + _UPN, + _USSN, + _VIN, ), - shape_type=ShapeType.DOUBLE, -) - -GUARDRAIL_AUTOMATED_REASONING_INPUT_TEXT_REFERENCE = Schema.collection( - id=ShapeID( - "com.amazonaws.bedrockruntime#GuardrailAutomatedReasoningInputTextReference" + ( + (-1, 0), + (-1, 0), + (-1, 0), + (-1, 0), + (-1, 0), + (-1, 0), + (-1, 0), + (-1, 0), + (-1, 0), + (-1, 0), + (-1, 0), + (-1, 0), + (-1, 0), + (-1, 0), + (-1, 0), + (-1, 0), + (-1, 0), + (-1, 0), + (-1, 0), + (-1, 0), + (-1, 0), + (-1, 0), + (-1, 0), + (-1, 0), + (-1, 0), + (-1, 0), + (-1, 0), + (-1, 0), + (-1, 0), + (-1, 0), + (-1, 0), ), - members={ - "text": { - "target": GUARDRAIL_AUTOMATED_REASONING_STATEMENT_NATURAL_LANGUAGE_CONTENT - } - }, ) -GUARDRAIL_AUTOMATED_REASONING_INPUT_TEXT_REFERENCE_LIST = Schema.collection( - id=ShapeID( - "com.amazonaws.bedrockruntime#GuardrailAutomatedReasoningInputTextReferenceList" +GUARDRAIL_PII_ENTITY_FILTER: StaticSchema = ( + 18, + n0, + _GPEF, + 0, + (_ma, _ty, _a, _d), + ( + (3, 1), + (GUARDRAIL_PII_ENTITY_TYPE, 1), + (GUARDRAIL_SENSITIVE_INFORMATION_POLICY_ACTION, 1), + (2, 0), ), - shape_type=ShapeType.LIST, - members={"member": {"target": GUARDRAIL_AUTOMATED_REASONING_INPUT_TEXT_REFERENCE}}, -) - -GUARDRAIL_AUTOMATED_REASONING_TRANSLATION = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#GuardrailAutomatedReasoningTranslation"), - members={ - "premises": {"target": GUARDRAIL_AUTOMATED_REASONING_STATEMENT_LIST}, - "claims": {"target": GUARDRAIL_AUTOMATED_REASONING_STATEMENT_LIST}, - "untranslatedPremises": { - "target": GUARDRAIL_AUTOMATED_REASONING_INPUT_TEXT_REFERENCE_LIST - }, - "untranslatedClaims": { - "target": GUARDRAIL_AUTOMATED_REASONING_INPUT_TEXT_REFERENCE_LIST - }, - "confidence": {"target": GUARDRAIL_AUTOMATED_REASONING_TRANSLATION_CONFIDENCE}, - }, ) -GUARDRAIL_AUTOMATED_REASONING_IMPOSSIBLE_FINDING = Schema.collection( - id=ShapeID( - "com.amazonaws.bedrockruntime#GuardrailAutomatedReasoningImpossibleFinding" +GUARDRAIL_PII_ENTITY_FILTER_LIST: StaticSchema = ( + 16, + n0, + _GPEFL, + 0, + (_me,), + ((GUARDRAIL_PII_ENTITY_FILTER, 0),), +) + +GUARDRAIL_REGEX_FILTER: StaticSchema = ( + 18, + n0, + _GRF, + 0, + (_n, _ma, _r, _a, _d), + ( + (3, 0), + (3, 0), + (3, 0), + (GUARDRAIL_SENSITIVE_INFORMATION_POLICY_ACTION, 1), + (2, 0), ), - members={ - "translation": {"target": GUARDRAIL_AUTOMATED_REASONING_TRANSLATION}, - "contradictingRules": {"target": GUARDRAIL_AUTOMATED_REASONING_RULE_LIST}, - "logicWarning": {"target": GUARDRAIL_AUTOMATED_REASONING_LOGIC_WARNING}, - }, ) -GUARDRAIL_AUTOMATED_REASONING_INVALID_FINDING = Schema.collection( - id=ShapeID( - "com.amazonaws.bedrockruntime#GuardrailAutomatedReasoningInvalidFinding" +GUARDRAIL_REGEX_FILTER_LIST: StaticSchema = ( + 16, + n0, + _GRFL, + 0, + (_me,), + ((GUARDRAIL_REGEX_FILTER, 0),), +) + +GUARDRAIL_SENSITIVE_INFORMATION_POLICY_ASSESSMENT: StaticSchema = ( + 18, + n0, + _GSIPAu, + 0, + (_pE, _re), + ((GUARDRAIL_PII_ENTITY_FILTER_LIST, 1), (GUARDRAIL_REGEX_FILTER_LIST, 1)), +) + +GUARDRAIL_TOPIC_POLICY_ACTION: StaticSchema = ( + 14, + n0, + _GTPA, + 0, + (_BLOCKED, _NONE), + ((-1, 0), (-1, 0)), +) + +GUARDRAIL_TOPIC_TYPE: StaticSchema = (14, n0, _GTT, 0, (_DENY,), ((-1, 0),)) + +GUARDRAIL_TOPIC: StaticSchema = ( + 18, + n0, + _GT, + 0, + (_n, _ty, _a, _d), + ((3, 1), (GUARDRAIL_TOPIC_TYPE, 1), (GUARDRAIL_TOPIC_POLICY_ACTION, 1), (2, 0)), +) + +GUARDRAIL_TOPIC_LIST: StaticSchema = (16, n0, _GTL, 0, (_me,), ((GUARDRAIL_TOPIC, 0),)) + +GUARDRAIL_TOPIC_POLICY_ASSESSMENT: StaticSchema = ( + 18, + n0, + _GTPAu, + 0, + (_top,), + ((GUARDRAIL_TOPIC_LIST, 1),), +) + +GUARDRAIL_WORD_POLICY_ACTION: StaticSchema = ( + 14, + n0, + _GWPA, + 0, + (_BLOCKED, _NONE), + ((-1, 0), (-1, 0)), +) + +GUARDRAIL_CUSTOM_WORD: StaticSchema = ( + 18, + n0, + _GCW, + 0, + (_ma, _a, _d), + ((3, 1), (GUARDRAIL_WORD_POLICY_ACTION, 1), (2, 0)), +) + +GUARDRAIL_CUSTOM_WORD_LIST: StaticSchema = ( + 16, + n0, + _GCWL, + 0, + (_me,), + ((GUARDRAIL_CUSTOM_WORD, 0),), +) + +GUARDRAIL_MANAGED_WORD_TYPE: StaticSchema = ( + 14, + n0, + _GMWT, + 0, + (_PROFANITY,), + ((-1, 0),), +) + +GUARDRAIL_MANAGED_WORD: StaticSchema = ( + 18, + n0, + _GMW, + 0, + (_ma, _ty, _a, _d), + ( + (3, 1), + (GUARDRAIL_MANAGED_WORD_TYPE, 1), + (GUARDRAIL_WORD_POLICY_ACTION, 1), + (2, 0), ), - members={ - "translation": {"target": GUARDRAIL_AUTOMATED_REASONING_TRANSLATION}, - "contradictingRules": {"target": GUARDRAIL_AUTOMATED_REASONING_RULE_LIST}, - "logicWarning": {"target": GUARDRAIL_AUTOMATED_REASONING_LOGIC_WARNING}, - }, -) - -GUARDRAIL_AUTOMATED_REASONING_NO_TRANSLATIONS_FINDING = Schema.collection( - id=ShapeID( - "com.amazonaws.bedrockruntime#GuardrailAutomatedReasoningNoTranslationsFinding" - ) ) -GUARDRAIL_AUTOMATED_REASONING_SCENARIO = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#GuardrailAutomatedReasoningScenario"), - members={"statements": {"target": GUARDRAIL_AUTOMATED_REASONING_STATEMENT_LIST}}, +GUARDRAIL_MANAGED_WORD_LIST: StaticSchema = ( + 16, + n0, + _GMWL, + 0, + (_me,), + ((GUARDRAIL_MANAGED_WORD, 0),), +) + +GUARDRAIL_WORD_POLICY_ASSESSMENT: StaticSchema = ( + 18, + n0, + _GWPAu, + 0, + (_cW, _mWL), + ((GUARDRAIL_CUSTOM_WORD_LIST, 1), (GUARDRAIL_MANAGED_WORD_LIST, 1)), +) + +GUARDRAIL_ASSESSMENT: StaticSchema = ( + 18, + n0, + _GAua, + 0, + (_tP, _cP, _wP, _sIP, _cGP, _aRPu, _iM, _aGD), + ( + (GUARDRAIL_TOPIC_POLICY_ASSESSMENT, 0), + (GUARDRAIL_CONTENT_POLICY_ASSESSMENT, 0), + (GUARDRAIL_WORD_POLICY_ASSESSMENT, 0), + (GUARDRAIL_SENSITIVE_INFORMATION_POLICY_ASSESSMENT, 0), + (GUARDRAIL_CONTEXTUAL_GROUNDING_POLICY_ASSESSMENT, 0), + (GUARDRAIL_AUTOMATED_REASONING_POLICY_ASSESSMENT, 0), + (GUARDRAIL_INVOCATION_METRICS, 0), + (APPLIED_GUARDRAIL_DETAILS, 0), + ), ) -GUARDRAIL_AUTOMATED_REASONING_SATISFIABLE_FINDING = Schema.collection( - id=ShapeID( - "com.amazonaws.bedrockruntime#GuardrailAutomatedReasoningSatisfiableFinding" +GUARDRAIL_ASSESSMENT_LIST: StaticSchema = ( + 16, + n0, + _GAL, + 0, + (_me,), + ((GUARDRAIL_ASSESSMENT, 0),), +) + +GUARDRAIL_OUTPUT_TEXT: StaticSchema = (3, n0, _GOT, 0) + +GUARDRAIL_OUTPUT_CONTENT: StaticSchema = ( + 18, + n0, + _GOC, + 0, + (_te,), + ((GUARDRAIL_OUTPUT_TEXT, 0),), +) + +GUARDRAIL_OUTPUT_CONTENT_LIST: StaticSchema = ( + 16, + n0, + _GOCL, + 0, + (_me,), + ((GUARDRAIL_OUTPUT_CONTENT, 0),), +) + +APPLY_GUARDRAIL_OUTPUT: StaticSchema = ( + 18, + n0, + _AGO, + {_sSI: _cAGRo}, + (_u, _a, _aR, _ou, _as, _gC), + ( + (GUARDRAIL_USAGE, 1), + (GUARDRAIL_ACTION, 1), + (3, 0), + (GUARDRAIL_OUTPUT_CONTENT_LIST, 1), + (GUARDRAIL_ASSESSMENT_LIST, 1), + (GUARDRAIL_COVERAGE, 0), ), - members={ - "translation": {"target": GUARDRAIL_AUTOMATED_REASONING_TRANSLATION}, - "claimsTrueScenario": {"target": GUARDRAIL_AUTOMATED_REASONING_SCENARIO}, - "claimsFalseScenario": {"target": GUARDRAIL_AUTOMATED_REASONING_SCENARIO}, - "logicWarning": {"target": GUARDRAIL_AUTOMATED_REASONING_LOGIC_WARNING}, - }, ) -GUARDRAIL_AUTOMATED_REASONING_TOO_COMPLEX_FINDING = Schema.collection( - id=ShapeID( - "com.amazonaws.bedrockruntime#GuardrailAutomatedReasoningTooComplexFinding" - ) +APPLY_GUARDRAIL: StaticOperationSchema = ( + 23, + n0, + _AG, + { + _smit: MappingProxyType( + { + "code": 200, + "method": "POST", + "uri": "/guardrail/{guardrailIdentifier}/version/{guardrailVersion}/apply", + } + ) + }, + APPLY_GUARDRAIL_INPUT, + APPLY_GUARDRAIL_OUTPUT, + ( + ACCESS_DENIED_EXCEPTION, + INTERNAL_SERVER_EXCEPTION, + RESOURCE_NOT_FOUND_EXCEPTION, + SERVICE_QUOTA_EXCEEDED_EXCEPTION, + SERVICE_UNAVAILABLE_EXCEPTION, + THROTTLING_EXCEPTION, + VALIDATION_EXCEPTION, + ), ) -GUARDRAIL_AUTOMATED_REASONING_DIFFERENCE_SCENARIO_LIST = Schema.collection( - id=ShapeID( - "com.amazonaws.bedrockruntime#GuardrailAutomatedReasoningDifferenceScenarioList" +GUARDRAIL_CHECKS_CONTENT_FILTER_CATEGORY: StaticSchema = ( + 14, + n0, + _GCCFC, + 0, + (_VIOLENCE, _HATE, _SEXUAL, _MISCONDUCT, _INSULTS), + ((-1, 0), (-1, 0), (-1, 0), (-1, 0), (-1, 0)), +) + +GUARDRAIL_CHECKS_CONTENT_FILTER_CATEGORY_CONFIG: StaticSchema = ( + 18, + n0, + _GCCFCC, + 0, + (_ca,), + ((GUARDRAIL_CHECKS_CONTENT_FILTER_CATEGORY, 1),), +) + +GUARDRAIL_CHECKS_CONTENT_FILTER_CATEGORY_CONFIG_LIST: StaticSchema = ( + 16, + n0, + _GCCFCCL, + 0, + (_me,), + ((GUARDRAIL_CHECKS_CONTENT_FILTER_CATEGORY_CONFIG, 0),), +) + +GUARDRAIL_CHECKS_CONTENT_FILTER_CONFIG: StaticSchema = ( + 18, + n0, + _GCCFCu, + 0, + (_cat,), + ((GUARDRAIL_CHECKS_CONTENT_FILTER_CATEGORY_CONFIG_LIST, 1),), +) + +GUARDRAIL_CHECKS_PROMPT_ATTACK_CATEGORY: StaticSchema = ( + 14, + n0, + _GCPAC, + 0, + (_JAILBREAK, _PI, _PL), + ((-1, 0), (-1, 0), (-1, 0)), +) + +GUARDRAIL_CHECKS_PROMPT_ATTACK_CATEGORY_CONFIG: StaticSchema = ( + 18, + n0, + _GCPACC, + 0, + (_ca,), + ((GUARDRAIL_CHECKS_PROMPT_ATTACK_CATEGORY, 1),), +) + +GUARDRAIL_CHECKS_PROMPT_ATTACK_CATEGORY_CONFIG_LIST: StaticSchema = ( + 16, + n0, + _GCPACCL, + 0, + (_me,), + ((GUARDRAIL_CHECKS_PROMPT_ATTACK_CATEGORY_CONFIG, 0),), +) + +GUARDRAIL_CHECKS_PROMPT_ATTACK_CONFIG: StaticSchema = ( + 18, + n0, + _GCPACu, + 0, + (_cat,), + ((GUARDRAIL_CHECKS_PROMPT_ATTACK_CATEGORY_CONFIG_LIST, 1),), +) + +GUARDRAIL_CHECKS_SENSITIVE_INFORMATION_ENTITY_TYPE: StaticSchema = ( + 14, + n0, + _GCSIET, + 0, + ( + _ADDRESS, + _AGE, + _AAK, + _ASK, + _CHN, + _CSIN, + _CDCC, + _CDCE, + _CDCN, + _DI, + _EMAIL, + _IBAN, + _IA_, + _LP, + _MA, + _NAME, + _PASSWORD, + _PHONE, + _PIN, + _SC, + _UNHSN, + _UNIN, + _UUTRN, + _URL, + _USERNAME, + _UBAN, + _UBRN, + _UITIN, + _UPN, + _USSN, + _VIN, + ), + ( + (-1, 0), + (-1, 0), + (-1, 0), + (-1, 0), + (-1, 0), + (-1, 0), + (-1, 0), + (-1, 0), + (-1, 0), + (-1, 0), + (-1, 0), + (-1, 0), + (-1, 0), + (-1, 0), + (-1, 0), + (-1, 0), + (-1, 0), + (-1, 0), + (-1, 0), + (-1, 0), + (-1, 0), + (-1, 0), + (-1, 0), + (-1, 0), + (-1, 0), + (-1, 0), + (-1, 0), + (-1, 0), + (-1, 0), + (-1, 0), + (-1, 0), ), - shape_type=ShapeType.LIST, - members={"member": {"target": GUARDRAIL_AUTOMATED_REASONING_SCENARIO}}, ) -GUARDRAIL_AUTOMATED_REASONING_TRANSLATION_LIST = Schema.collection( - id=ShapeID( - "com.amazonaws.bedrockruntime#GuardrailAutomatedReasoningTranslationList" +GUARDRAIL_CHECKS_SENSITIVE_INFORMATION_ENTITY_CONFIG: StaticSchema = ( + 18, + n0, + _GCSIEC, + 0, + (_ty,), + ((GUARDRAIL_CHECKS_SENSITIVE_INFORMATION_ENTITY_TYPE, 1),), +) + +GUARDRAIL_CHECKS_SENSITIVE_INFORMATION_ENTITY_CONFIG_LIST: StaticSchema = ( + 16, + n0, + _GCSIECL, + 0, + (_me,), + ((GUARDRAIL_CHECKS_SENSITIVE_INFORMATION_ENTITY_CONFIG, 0),), +) + +GUARDRAIL_CHECKS_SENSITIVE_INFORMATION_CONFIG: StaticSchema = ( + 18, + n0, + _GCSIC, + 0, + (_e,), + ((GUARDRAIL_CHECKS_SENSITIVE_INFORMATION_ENTITY_CONFIG_LIST, 1),), +) + +GUARDRAIL_CHECKS_CONFIG: StaticSchema = ( + 18, + n0, + _GCC, + 0, + (_cF, _pA, _sI), + ( + (GUARDRAIL_CHECKS_CONTENT_FILTER_CONFIG, 0), + (GUARDRAIL_CHECKS_PROMPT_ATTACK_CONFIG, 0), + (GUARDRAIL_CHECKS_SENSITIVE_INFORMATION_CONFIG, 0), ), - shape_type=ShapeType.LIST, - members={"member": {"target": GUARDRAIL_AUTOMATED_REASONING_TRANSLATION}}, ) -GUARDRAIL_AUTOMATED_REASONING_TRANSLATION_OPTION = Schema.collection( - id=ShapeID( - "com.amazonaws.bedrockruntime#GuardrailAutomatedReasoningTranslationOption" +GUARDRAIL_CHECKS_TEXT_CONTENT: StaticSchema = (3, n0, _GCTC, 4) + +GUARDRAIL_CHECKS_CONTENT_BLOCK: StaticSchema = ( + 19, + n0, + _GCCB, + 0, + (_te,), + ((GUARDRAIL_CHECKS_TEXT_CONTENT, 0),), +) + +GUARDRAIL_CHECKS_CONTENT_BLOCK_LIST: StaticSchema = ( + 16, + n0, + _GCCBL, + 0, + (_me,), + ((GUARDRAIL_CHECKS_CONTENT_BLOCK, 0),), +) + +GUARDRAIL_CHECKS_ROLE: StaticSchema = ( + 14, + n0, + _GCR, + 0, + (_USER, _ASSISTANT, _SYSTEM), + ((-1, 0), (-1, 0), (-1, 0)), +) + +GUARDRAIL_CHECKS_MESSAGE: StaticSchema = ( + 18, + n0, + _GCM, + 0, + (_ro, _co), + ((GUARDRAIL_CHECKS_ROLE, 1), (GUARDRAIL_CHECKS_CONTENT_BLOCK_LIST, 1)), +) + +GUARDRAIL_CHECKS_MESSAGE_LIST: StaticSchema = ( + 16, + n0, + _GCML, + 0, + (_me,), + ((GUARDRAIL_CHECKS_MESSAGE, 0),), +) + +INVOKE_GUARDRAIL_CHECKS_INPUT: StaticSchema = ( + 18, + n0, + _IGCI, + {_sSI: _cIGCR}, + (_mes, _ch), + ((GUARDRAIL_CHECKS_MESSAGE_LIST, 1), (GUARDRAIL_CHECKS_CONFIG, 1)), +) + +GUARDRAIL_CHECKS_CONTENT_FILTER_RESULT_ENTRY: StaticSchema = ( + 18, + n0, + _GCCFRE, + 0, + (_ca, _sS), + ((GUARDRAIL_CHECKS_CONTENT_FILTER_CATEGORY, 1), (10, 1)), +) + +GUARDRAIL_CHECKS_CONTENT_FILTER_RESULT_LIST: StaticSchema = ( + 16, + n0, + _GCCFRL, + 0, + (_me,), + ((GUARDRAIL_CHECKS_CONTENT_FILTER_RESULT_ENTRY, 0),), +) + +GUARDRAIL_CHECKS_CONTENT_FILTER_RESULT: StaticSchema = ( + 18, + n0, + _GCCFR, + 0, + (_res,), + ((GUARDRAIL_CHECKS_CONTENT_FILTER_RESULT_LIST, 1),), +) + +GUARDRAIL_CHECKS_PROMPT_ATTACK_RESULT_ENTRY: StaticSchema = ( + 18, + n0, + _GCPARE, + 0, + (_ca, _sS), + ((GUARDRAIL_CHECKS_PROMPT_ATTACK_CATEGORY, 1), (10, 1)), +) + +GUARDRAIL_CHECKS_PROMPT_ATTACK_RESULT_LIST: StaticSchema = ( + 16, + n0, + _GCPARL, + 0, + (_me,), + ((GUARDRAIL_CHECKS_PROMPT_ATTACK_RESULT_ENTRY, 0),), +) + +GUARDRAIL_CHECKS_PROMPT_ATTACK_RESULT: StaticSchema = ( + 18, + n0, + _GCPAR, + 0, + (_res,), + ((GUARDRAIL_CHECKS_PROMPT_ATTACK_RESULT_LIST, 1),), +) + +GUARDRAIL_CHECKS_SENSITIVE_INFORMATION_RESULT_ENTRY: StaticSchema = ( + 18, + n0, + _GCSIRE, + 0, + (_ty, _cS, _bOe, _eO, _mIe, _cI), + ( + (GUARDRAIL_CHECKS_SENSITIVE_INFORMATION_ENTITY_TYPE, 1), + (10, 1), + (7, 1), + (7, 1), + (7, 1), + (7, 1), ), - members={ - "translations": {"target": GUARDRAIL_AUTOMATED_REASONING_TRANSLATION_LIST} - }, ) -GUARDRAIL_AUTOMATED_REASONING_TRANSLATION_OPTION_LIST = Schema.collection( - id=ShapeID( - "com.amazonaws.bedrockruntime#GuardrailAutomatedReasoningTranslationOptionList" +GUARDRAIL_CHECKS_SENSITIVE_INFORMATION_RESULT_LIST: StaticSchema = ( + 16, + n0, + _GCSIRL, + 0, + (_me,), + ((GUARDRAIL_CHECKS_SENSITIVE_INFORMATION_RESULT_ENTRY, 0),), +) + +GUARDRAIL_CHECKS_SENSITIVE_INFORMATION_RESULT: StaticSchema = ( + 18, + n0, + _GCSIR, + 0, + (_res, _tru), + ((GUARDRAIL_CHECKS_SENSITIVE_INFORMATION_RESULT_LIST, 1), (2, 0)), +) + +GUARDRAIL_CHECKS_RESULTS: StaticSchema = ( + 18, + n0, + _GCRu, + 0, + (_cF, _pA, _sI), + ( + (GUARDRAIL_CHECKS_CONTENT_FILTER_RESULT, 0), + (GUARDRAIL_CHECKS_PROMPT_ATTACK_RESULT, 0), + (GUARDRAIL_CHECKS_SENSITIVE_INFORMATION_RESULT, 0), ), - shape_type=ShapeType.LIST, - members={"member": {"target": GUARDRAIL_AUTOMATED_REASONING_TRANSLATION_OPTION}}, ) -GUARDRAIL_AUTOMATED_REASONING_TRANSLATION_AMBIGUOUS_FINDING = Schema.collection( - id=ShapeID( - "com.amazonaws.bedrockruntime#GuardrailAutomatedReasoningTranslationAmbiguousFinding" +GUARDRAIL_CHECKS_CONTENT_FILTER_USAGE: StaticSchema = ( + 18, + n0, + _GCCFU, + 0, + (_tU,), + ((7, 1),), +) + +GUARDRAIL_CHECKS_PROMPT_ATTACK_USAGE: StaticSchema = ( + 18, + n0, + _GCPAU, + 0, + (_tU,), + ((7, 1),), +) + +GUARDRAIL_CHECKS_SENSITIVE_INFORMATION_USAGE: StaticSchema = ( + 18, + n0, + _GCSIU, + 0, + (_tU,), + ((7, 1),), +) + +GUARDRAIL_CHECKS_USAGE_RESULTS: StaticSchema = ( + 18, + n0, + _GCUR, + 0, + (_cF, _pA, _sI), + ( + (GUARDRAIL_CHECKS_CONTENT_FILTER_USAGE, 0), + (GUARDRAIL_CHECKS_PROMPT_ATTACK_USAGE, 0), + (GUARDRAIL_CHECKS_SENSITIVE_INFORMATION_USAGE, 0), ), - members={ - "options": {"target": GUARDRAIL_AUTOMATED_REASONING_TRANSLATION_OPTION_LIST}, - "differenceScenarios": { - "target": GUARDRAIL_AUTOMATED_REASONING_DIFFERENCE_SCENARIO_LIST - }, - }, ) -GUARDRAIL_AUTOMATED_REASONING_VALID_FINDING = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#GuardrailAutomatedReasoningValidFinding"), - members={ - "translation": {"target": GUARDRAIL_AUTOMATED_REASONING_TRANSLATION}, - "claimsTrueScenario": {"target": GUARDRAIL_AUTOMATED_REASONING_SCENARIO}, - "supportingRules": {"target": GUARDRAIL_AUTOMATED_REASONING_RULE_LIST}, - "logicWarning": {"target": GUARDRAIL_AUTOMATED_REASONING_LOGIC_WARNING}, - }, +INVOKE_GUARDRAIL_CHECKS_OUTPUT: StaticSchema = ( + 18, + n0, + _IGCO, + {_sSI: _cIGCRo}, + (_res, _u), + ((GUARDRAIL_CHECKS_RESULTS, 1), (GUARDRAIL_CHECKS_USAGE_RESULTS, 1)), ) -GUARDRAIL_AUTOMATED_REASONING_FINDING = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#GuardrailAutomatedReasoningFinding"), - shape_type=ShapeType.UNION, - members={ - "valid": {"target": GUARDRAIL_AUTOMATED_REASONING_VALID_FINDING}, - "invalid": {"target": GUARDRAIL_AUTOMATED_REASONING_INVALID_FINDING}, - "satisfiable": {"target": GUARDRAIL_AUTOMATED_REASONING_SATISFIABLE_FINDING}, - "impossible": {"target": GUARDRAIL_AUTOMATED_REASONING_IMPOSSIBLE_FINDING}, - "translationAmbiguous": { - "target": GUARDRAIL_AUTOMATED_REASONING_TRANSLATION_AMBIGUOUS_FINDING - }, - "tooComplex": {"target": GUARDRAIL_AUTOMATED_REASONING_TOO_COMPLEX_FINDING}, - "noTranslations": { - "target": GUARDRAIL_AUTOMATED_REASONING_NO_TRANSLATIONS_FINDING - }, +INVOKE_GUARDRAIL_CHECKS: StaticOperationSchema = ( + 23, + n0, + _IGC, + { + _smit: MappingProxyType( + {"code": 200, "method": "POST", "uri": "/guardrail-checks/invoke"} + ) }, + INVOKE_GUARDRAIL_CHECKS_INPUT, + INVOKE_GUARDRAIL_CHECKS_OUTPUT, + ( + ACCESS_DENIED_EXCEPTION, + INTERNAL_SERVER_EXCEPTION, + SERVICE_UNAVAILABLE_EXCEPTION, + THROTTLING_EXCEPTION, + VALIDATION_EXCEPTION, + ), ) -GUARDRAIL_AUTOMATED_REASONING_FINDING_LIST = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#GuardrailAutomatedReasoningFindingList"), - shape_type=ShapeType.LIST, - members={"member": {"target": GUARDRAIL_AUTOMATED_REASONING_FINDING}}, +GUARDRAIL_TRACE: StaticSchema = ( + 14, + n0, + _GTu, + 0, + (_ENABLED, _DISABLED, _EF), + ((-1, 0), (-1, 0), (-1, 0)), +) + +GUARDRAIL_CONFIGURATION: StaticSchema = ( + 18, + n0, + _GCua, + 0, + (_gI, _gV, _trac), + ( + (GUARDRAIL_IDENTIFIER, {_smith: _v_}), + (GUARDRAIL_VERSION, {_smith: _v_}), + (GUARDRAIL_TRACE, {_smith: _di}), + ), ) -GUARDRAIL_AUTOMATED_REASONING_POLICY_ASSESSMENT = Schema.collection( - id=ShapeID( - "com.amazonaws.bedrockruntime#GuardrailAutomatedReasoningPolicyAssessment" +NON_EMPTY_STRING: StaticSchema = (3, n0, _NES, 0) + +NON_EMPTY_STRING_LIST: StaticSchema = ( + 16, + n0, + _NESL, + 0, + (_me,), + ((NON_EMPTY_STRING, 0),), +) + +INFERENCE_CONFIGURATION: StaticSchema = ( + 18, + n0, + _IC, + 0, + (_mT, _tem, _tPo, _sSt), + ((7, 0), (9, 0), (9, 0), (NON_EMPTY_STRING_LIST, 0)), +) + +ERROR_BLOCK: StaticSchema = (18, n0, _EB, 4, (_m,), ((3, 0),)) + +AUDIO_FORMAT: StaticSchema = ( + 14, + n0, + _AFu, + 0, + ( + _MP, + _OPUS, + _WAV, + _AAC, + _FLAC, + _MP_, + _OGG, + _MKV, + _MKA, + _XA, + _MA_, + _MPEG, + _MPGA, + _PCM, + _WEBM, + ), + ( + (-1, 0), + (-1, 0), + (-1, 0), + (-1, 0), + (-1, 0), + (-1, 0), + (-1, 0), + (-1, 0), + (-1, 0), + (-1, 0), + (-1, 0), + (-1, 0), + (-1, 0), + (-1, 0), + (-1, 0), ), - members={"findings": {"target": GUARDRAIL_AUTOMATED_REASONING_FINDING_LIST}}, ) -GUARDRAIL_CONTENT_POLICY_ACTION = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#GuardrailContentPolicyAction"), - shape_type=ShapeType.ENUM, - members={"BLOCKED": {"target": UNIT}, "NONE": {"target": UNIT}}, -) +S3_LOCATION: StaticSchema = (18, n0, _SL, 0, (_ur, _bO), ((S3_URI, 1), (ACCOUNT_ID, 0))) -GUARDRAIL_CONTENT_FILTER_CONFIDENCE = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#GuardrailContentFilterConfidence"), - shape_type=ShapeType.ENUM, - members={ - "NONE": {"target": UNIT}, - "LOW": {"target": UNIT}, - "MEDIUM": {"target": UNIT}, - "HIGH": {"target": UNIT}, - }, -) +AUDIO_SOURCE: StaticSchema = (19, n0, _AS, 4, (_b, _sLo), ((1, 0), (S3_LOCATION, 0))) -GUARDRAIL_CONTENT_FILTER_STRENGTH = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#GuardrailContentFilterStrength"), - shape_type=ShapeType.ENUM, - members={ - "NONE": {"target": UNIT}, - "LOW": {"target": UNIT}, - "MEDIUM": {"target": UNIT}, - "HIGH": {"target": UNIT}, - }, +AUDIO_BLOCK: StaticSchema = ( + 18, + n0, + _AB, + 0, + (_f, _so, _er), + ((AUDIO_FORMAT, 1), (AUDIO_SOURCE, 1), (ERROR_BLOCK, 0)), ) -GUARDRAIL_CONTENT_FILTER_TYPE = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#GuardrailContentFilterType"), - shape_type=ShapeType.ENUM, - members={ - "INSULTS": {"target": UNIT}, - "HATE": {"target": UNIT}, - "SEXUAL": {"target": UNIT}, - "VIOLENCE": {"target": UNIT}, - "MISCONDUCT": {"target": UNIT}, - "PROMPT_ATTACK": {"target": UNIT}, - }, -) +CACHE_TTL: StaticSchema = (14, n0, _CTTL, 0, (_FM, _OH), ((-1, 0), (-1, 0))) -GUARDRAIL_CONTENT_FILTER = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#GuardrailContentFilter"), - members={ - "type": { - "target": GUARDRAIL_CONTENT_FILTER_TYPE, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - "confidence": { - "target": GUARDRAIL_CONTENT_FILTER_CONFIDENCE, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - "filterStrength": {"target": GUARDRAIL_CONTENT_FILTER_STRENGTH}, - "action": { - "target": GUARDRAIL_CONTENT_POLICY_ACTION, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - "detected": {"target": BOOLEAN}, - }, -) +CACHE_POINT_TYPE: StaticSchema = (14, n0, _CPT, 0, (_DEFAULT,), ((-1, 0),)) -GUARDRAIL_CONTENT_FILTER_LIST = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#GuardrailContentFilterList"), - shape_type=ShapeType.LIST, - members={"member": {"target": GUARDRAIL_CONTENT_FILTER}}, +CACHE_POINT_BLOCK: StaticSchema = ( + 18, + n0, + _CPB, + 0, + (_ty, _tt), + ((CACHE_POINT_TYPE, 1), (CACHE_TTL, 0)), ) -GUARDRAIL_CONTENT_POLICY_ASSESSMENT = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#GuardrailContentPolicyAssessment"), - members={ - "filters": { - "target": GUARDRAIL_CONTENT_FILTER_LIST, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - } - }, +DOCUMENT_CHAR_LOCATION: StaticSchema = ( + 18, + n0, + _DCL, + 0, + (_dI, _star, _en), + ((7, 0), (7, 0), (7, 0)), ) -GUARDRAIL_CONTEXTUAL_GROUNDING_POLICY_ACTION = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#GuardrailContextualGroundingPolicyAction"), - shape_type=ShapeType.ENUM, - members={"BLOCKED": {"target": UNIT}, "NONE": {"target": UNIT}}, -) - -GUARDRAIL_CONTEXTUAL_GROUNDING_FILTER_TYPE = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#GuardrailContextualGroundingFilterType"), - shape_type=ShapeType.ENUM, - members={"GROUNDING": {"target": UNIT}, "RELEVANCE": {"target": UNIT}}, -) - -GUARDRAIL_CONTEXTUAL_GROUNDING_FILTER = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#GuardrailContextualGroundingFilter"), - members={ - "type": { - "target": GUARDRAIL_CONTEXTUAL_GROUNDING_FILTER_TYPE, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - "threshold": { - "target": DOUBLE, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - "score": { - "target": DOUBLE, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - "action": { - "target": GUARDRAIL_CONTEXTUAL_GROUNDING_POLICY_ACTION, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - "detected": {"target": BOOLEAN}, - }, +DOCUMENT_CHUNK_LOCATION: StaticSchema = ( + 18, + n0, + _DCLo, + 0, + (_dI, _star, _en), + ((7, 0), (7, 0), (7, 0)), ) -GUARDRAIL_CONTEXTUAL_GROUNDING_FILTERS = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#GuardrailContextualGroundingFilters"), - shape_type=ShapeType.LIST, - members={"member": {"target": GUARDRAIL_CONTEXTUAL_GROUNDING_FILTER}}, +DOCUMENT_PAGE_LOCATION: StaticSchema = ( + 18, + n0, + _DPL, + 0, + (_dI, _star, _en), + ((7, 0), (7, 0), (7, 0)), ) -GUARDRAIL_CONTEXTUAL_GROUNDING_POLICY_ASSESSMENT = Schema.collection( - id=ShapeID( - "com.amazonaws.bedrockruntime#GuardrailContextualGroundingPolicyAssessment" - ), - members={"filters": {"target": GUARDRAIL_CONTEXTUAL_GROUNDING_FILTERS}}, +SEARCH_RESULT_LOCATION: StaticSchema = ( + 18, + n0, + _SRL, + 0, + (_sRI, _star, _en), + ((7, 0), (7, 0), (7, 0)), ) -IMAGES_GUARDED = Schema( - id=ShapeID("com.amazonaws.bedrockruntime#ImagesGuarded"), - shape_type=ShapeType.INTEGER, -) +WEB_LOCATION: StaticSchema = (18, n0, _WL, 0, (_url, _do), ((3, 0), (3, 0))) -IMAGES_TOTAL = Schema( - id=ShapeID("com.amazonaws.bedrockruntime#ImagesTotal"), shape_type=ShapeType.INTEGER +CITATION_LOCATION: StaticSchema = ( + 19, + n0, + _CL, + 0, + (_w, _dC, _dP, _dCo, _sRL), + ( + (WEB_LOCATION, 0), + (DOCUMENT_CHAR_LOCATION, 0), + (DOCUMENT_PAGE_LOCATION, 0), + (DOCUMENT_CHUNK_LOCATION, 0), + (SEARCH_RESULT_LOCATION, 0), + ), ) -GUARDRAIL_IMAGE_COVERAGE = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#GuardrailImageCoverage"), - members={"guarded": {"target": IMAGES_GUARDED}, "total": {"target": IMAGES_TOTAL}}, -) +CITATION_SOURCE_CONTENT: StaticSchema = (19, n0, _CSC, 0, (_te,), ((3, 0),)) -TEXT_CHARACTERS_GUARDED = Schema( - id=ShapeID("com.amazonaws.bedrockruntime#TextCharactersGuarded"), - shape_type=ShapeType.INTEGER, +CITATION_SOURCE_CONTENT_LIST: StaticSchema = ( + 16, + n0, + _CSCL, + 0, + (_me,), + ((CITATION_SOURCE_CONTENT, 0),), ) -TEXT_CHARACTERS_TOTAL = Schema( - id=ShapeID("com.amazonaws.bedrockruntime#TextCharactersTotal"), - shape_type=ShapeType.INTEGER, +CITATION: StaticSchema = ( + 18, + n0, + _C, + 0, + (_ti, _so, _sC, _lo), + ((3, 0), (3, 0), (CITATION_SOURCE_CONTENT_LIST, 0), (CITATION_LOCATION, 0)), ) -GUARDRAIL_TEXT_CHARACTERS_COVERAGE = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#GuardrailTextCharactersCoverage"), - members={ - "guarded": {"target": TEXT_CHARACTERS_GUARDED}, - "total": {"target": TEXT_CHARACTERS_TOTAL}, - }, -) +CITATIONS: StaticSchema = (16, n0, _Ci, 0, (_me,), ((CITATION, 0),)) -GUARDRAIL_COVERAGE = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#GuardrailCoverage"), - members={ - "textCharacters": {"target": GUARDRAIL_TEXT_CHARACTERS_COVERAGE}, - "images": {"target": GUARDRAIL_IMAGE_COVERAGE}, - }, -) +CITATION_GENERATED_CONTENT: StaticSchema = (19, n0, _CGC, 0, (_te,), ((3, 0),)) -GUARDRAIL_PROCESSING_LATENCY = Schema( - id=ShapeID("com.amazonaws.bedrockruntime#GuardrailProcessingLatency"), - shape_type=ShapeType.LONG, +CITATION_GENERATED_CONTENT_LIST: StaticSchema = ( + 16, + n0, + _CGCL, + 0, + (_me,), + ((CITATION_GENERATED_CONTENT, 0),), ) -GUARDRAIL_AUTOMATED_REASONING_POLICIES_PROCESSED = Schema( - id=ShapeID( - "com.amazonaws.bedrockruntime#GuardrailAutomatedReasoningPoliciesProcessed" - ), - shape_type=ShapeType.INTEGER, +CITATIONS_CONTENT_BLOCK: StaticSchema = ( + 18, + n0, + _CCB, + 0, + (_co, _ci), + ((CITATION_GENERATED_CONTENT_LIST, 0), (CITATIONS, 0)), ) -GUARDRAIL_AUTOMATED_REASONING_POLICY_UNITS_PROCESSED = Schema( - id=ShapeID( - "com.amazonaws.bedrockruntime#GuardrailAutomatedReasoningPolicyUnitsProcessed" - ), - shape_type=ShapeType.INTEGER, -) +CITATIONS_CONFIG: StaticSchema = (18, n0, _CC, 0, (_ena,), ((2, 1),)) -GUARDRAIL_CONTENT_POLICY_IMAGE_UNITS_PROCESSED = Schema( - id=ShapeID( - "com.amazonaws.bedrockruntime#GuardrailContentPolicyImageUnitsProcessed" - ), - shape_type=ShapeType.INTEGER, +DOCUMENT_FORMAT: StaticSchema = ( + 14, + n0, + _DF, + 0, + (_PDF, _CSV, _DOC, _DOCX, _XLS, _XLSX, _HTML, _TXT, _MD), + ((-1, 0), (-1, 0), (-1, 0), (-1, 0), (-1, 0), (-1, 0), (-1, 0), (-1, 0), (-1, 0)), ) -GUARDRAIL_CONTENT_POLICY_UNITS_PROCESSED = Schema( - id=ShapeID("com.amazonaws.bedrockruntime#GuardrailContentPolicyUnitsProcessed"), - shape_type=ShapeType.INTEGER, -) +DOCUMENT_CONTENT_BLOCK: StaticSchema = (19, n0, _DCB, 0, (_te,), ((3, 0),)) -GUARDRAIL_CONTEXTUAL_GROUNDING_POLICY_UNITS_PROCESSED = Schema( - id=ShapeID( - "com.amazonaws.bedrockruntime#GuardrailContextualGroundingPolicyUnitsProcessed" - ), - shape_type=ShapeType.INTEGER, +DOCUMENT_CONTENT_BLOCKS: StaticSchema = ( + 16, + n0, + _DCBo, + 0, + (_me,), + ((DOCUMENT_CONTENT_BLOCK, 0),), ) -GUARDRAIL_SENSITIVE_INFORMATION_POLICY_FREE_UNITS_PROCESSED = Schema( - id=ShapeID( - "com.amazonaws.bedrockruntime#GuardrailSensitiveInformationPolicyFreeUnitsProcessed" - ), - shape_type=ShapeType.INTEGER, +DOCUMENT_SOURCE: StaticSchema = ( + 19, + n0, + _DS, + 0, + (_b, _sLo, _te, _co), + ((1, 0), (S3_LOCATION, 0), (3, 0), (DOCUMENT_CONTENT_BLOCKS, 0)), ) -GUARDRAIL_SENSITIVE_INFORMATION_POLICY_UNITS_PROCESSED = Schema( - id=ShapeID( - "com.amazonaws.bedrockruntime#GuardrailSensitiveInformationPolicyUnitsProcessed" +DOCUMENT_BLOCK: StaticSchema = ( + 18, + n0, + _DB, + 0, + (_f, _n, _so, _cont, _ci), + ( + (DOCUMENT_FORMAT, {_smith: _tx}), + (3, 1), + (DOCUMENT_SOURCE, 1), + (3, 0), + (CITATIONS_CONFIG, 0), ), - shape_type=ShapeType.INTEGER, -) - -GUARDRAIL_TOPIC_POLICY_UNITS_PROCESSED = Schema( - id=ShapeID("com.amazonaws.bedrockruntime#GuardrailTopicPolicyUnitsProcessed"), - shape_type=ShapeType.INTEGER, -) - -GUARDRAIL_WORD_POLICY_UNITS_PROCESSED = Schema( - id=ShapeID("com.amazonaws.bedrockruntime#GuardrailWordPolicyUnitsProcessed"), - shape_type=ShapeType.INTEGER, -) - -GUARDRAIL_USAGE = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#GuardrailUsage"), - members={ - "topicPolicyUnits": { - "target": GUARDRAIL_TOPIC_POLICY_UNITS_PROCESSED, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - "contentPolicyUnits": { - "target": GUARDRAIL_CONTENT_POLICY_UNITS_PROCESSED, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - "wordPolicyUnits": { - "target": GUARDRAIL_WORD_POLICY_UNITS_PROCESSED, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - "sensitiveInformationPolicyUnits": { - "target": GUARDRAIL_SENSITIVE_INFORMATION_POLICY_UNITS_PROCESSED, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - "sensitiveInformationPolicyFreeUnits": { - "target": GUARDRAIL_SENSITIVE_INFORMATION_POLICY_FREE_UNITS_PROCESSED, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - "contextualGroundingPolicyUnits": { - "target": GUARDRAIL_CONTEXTUAL_GROUNDING_POLICY_UNITS_PROCESSED, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - "contentPolicyImageUnits": { - "target": GUARDRAIL_CONTENT_POLICY_IMAGE_UNITS_PROCESSED - }, - "automatedReasoningPolicyUnits": { - "target": GUARDRAIL_AUTOMATED_REASONING_POLICY_UNITS_PROCESSED - }, - "automatedReasoningPolicies": { - "target": GUARDRAIL_AUTOMATED_REASONING_POLICIES_PROCESSED - }, - }, ) -GUARDRAIL_INVOCATION_METRICS = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#GuardrailInvocationMetrics"), - members={ - "guardrailProcessingLatency": {"target": GUARDRAIL_PROCESSING_LATENCY}, - "usage": {"target": GUARDRAIL_USAGE}, - "guardrailCoverage": {"target": GUARDRAIL_COVERAGE}, - }, +GUARDRAIL_CONVERSE_IMAGE_FORMAT: StaticSchema = ( + 14, + n0, + _GCIF, + 0, + (_PNG, _JPEG), + ((-1, 0), (-1, 0)), ) -GUARDRAIL_SENSITIVE_INFORMATION_POLICY_ACTION = Schema.collection( - id=ShapeID( - "com.amazonaws.bedrockruntime#GuardrailSensitiveInformationPolicyAction" - ), - shape_type=ShapeType.ENUM, - members={ - "ANONYMIZED": {"target": UNIT}, - "BLOCKED": {"target": UNIT}, - "NONE": {"target": UNIT}, - }, -) +GUARDRAIL_CONVERSE_IMAGE_SOURCE: StaticSchema = (19, n0, _GCIS, 4, (_b,), ((1, 0),)) -GUARDRAIL_PII_ENTITY_TYPE = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#GuardrailPiiEntityType"), - shape_type=ShapeType.ENUM, - members={ - "ADDRESS": {"target": UNIT}, - "AGE": {"target": UNIT}, - "AWS_ACCESS_KEY": {"target": UNIT}, - "AWS_SECRET_KEY": {"target": UNIT}, - "CA_HEALTH_NUMBER": {"target": UNIT}, - "CA_SOCIAL_INSURANCE_NUMBER": {"target": UNIT}, - "CREDIT_DEBIT_CARD_CVV": {"target": UNIT}, - "CREDIT_DEBIT_CARD_EXPIRY": {"target": UNIT}, - "CREDIT_DEBIT_CARD_NUMBER": {"target": UNIT}, - "DRIVER_ID": {"target": UNIT}, - "EMAIL": {"target": UNIT}, - "INTERNATIONAL_BANK_ACCOUNT_NUMBER": {"target": UNIT}, - "IP_ADDRESS": {"target": UNIT}, - "LICENSE_PLATE": {"target": UNIT}, - "MAC_ADDRESS": {"target": UNIT}, - "NAME": {"target": UNIT}, - "PASSWORD": {"target": UNIT}, - "PHONE": {"target": UNIT}, - "PIN": {"target": UNIT}, - "SWIFT_CODE": {"target": UNIT}, - "UK_NATIONAL_HEALTH_SERVICE_NUMBER": {"target": UNIT}, - "UK_NATIONAL_INSURANCE_NUMBER": {"target": UNIT}, - "UK_UNIQUE_TAXPAYER_REFERENCE_NUMBER": {"target": UNIT}, - "URL": {"target": UNIT}, - "USERNAME": {"target": UNIT}, - "US_BANK_ACCOUNT_NUMBER": {"target": UNIT}, - "US_BANK_ROUTING_NUMBER": {"target": UNIT}, - "US_INDIVIDUAL_TAX_IDENTIFICATION_NUMBER": {"target": UNIT}, - "US_PASSPORT_NUMBER": {"target": UNIT}, - "US_SOCIAL_SECURITY_NUMBER": {"target": UNIT}, - "VEHICLE_IDENTIFICATION_NUMBER": {"target": UNIT}, - }, +GUARDRAIL_CONVERSE_IMAGE_BLOCK: StaticSchema = ( + 18, + n0, + _GCIB, + 4, + (_f, _so), + ((GUARDRAIL_CONVERSE_IMAGE_FORMAT, 1), (GUARDRAIL_CONVERSE_IMAGE_SOURCE, 1)), ) -GUARDRAIL_PII_ENTITY_FILTER = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#GuardrailPiiEntityFilter"), - members={ - "match": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - "type": { - "target": GUARDRAIL_PII_ENTITY_TYPE, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - "action": { - "target": GUARDRAIL_SENSITIVE_INFORMATION_POLICY_ACTION, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - "detected": {"target": BOOLEAN}, - }, +GUARDRAIL_CONVERSE_CONTENT_QUALIFIER: StaticSchema = ( + 14, + n0, + _GCCQ, + 0, + (_GS, _QUERY, _GC), + ((-1, 0), (-1, 0), (-1, 0)), ) -GUARDRAIL_PII_ENTITY_FILTER_LIST = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#GuardrailPiiEntityFilterList"), - shape_type=ShapeType.LIST, - members={"member": {"target": GUARDRAIL_PII_ENTITY_FILTER}}, +GUARDRAIL_CONVERSE_CONTENT_QUALIFIER_LIST: StaticSchema = ( + 16, + n0, + _GCCQL, + 0, + (_me,), + ((GUARDRAIL_CONVERSE_CONTENT_QUALIFIER, 0),), ) -GUARDRAIL_REGEX_FILTER = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#GuardrailRegexFilter"), - members={ - "name": {"target": STRING}, - "match": {"target": STRING}, - "regex": {"target": STRING}, - "action": { - "target": GUARDRAIL_SENSITIVE_INFORMATION_POLICY_ACTION, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - "detected": {"target": BOOLEAN}, - }, +GUARDRAIL_CONVERSE_TEXT_BLOCK: StaticSchema = ( + 18, + n0, + _GCTB, + 0, + (_te, _q), + ((3, 1), (GUARDRAIL_CONVERSE_CONTENT_QUALIFIER_LIST, 0)), ) -GUARDRAIL_REGEX_FILTER_LIST = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#GuardrailRegexFilterList"), - shape_type=ShapeType.LIST, - members={"member": {"target": GUARDRAIL_REGEX_FILTER}}, +GUARDRAIL_CONVERSE_CONTENT_BLOCK: StaticSchema = ( + 19, + n0, + _GCCBu, + 0, + (_te, _i), + ((GUARDRAIL_CONVERSE_TEXT_BLOCK, 0), (GUARDRAIL_CONVERSE_IMAGE_BLOCK, 0)), +) + +IMAGE_FORMAT: StaticSchema = ( + 14, + n0, + _IF, + 0, + (_PNG, _JPEG, _GIF_, _WEBP), + ((-1, 0), (-1, 0), (-1, 0), (-1, 0)), +) + +IMAGE_SOURCE: StaticSchema = (19, n0, _IS, 4, (_b, _sLo), ((1, 0), (S3_LOCATION, 0))) + +IMAGE_BLOCK: StaticSchema = ( + 18, + n0, + _IB, + 0, + (_f, _so, _er), + ((IMAGE_FORMAT, 1), (IMAGE_SOURCE, 1), (ERROR_BLOCK, 0)), +) + +REASONING_TEXT_BLOCK: StaticSchema = (18, n0, _RTB, 4, (_te, _si), ((3, 1), (3, 0))) + +REASONING_CONTENT_BLOCK: StaticSchema = ( + 19, + n0, + _RCB, + 4, + (_rT, _rC), + ((REASONING_TEXT_BLOCK, 0), (1, 0)), +) + +SEARCH_RESULT_CONTENT_BLOCK: StaticSchema = (18, n0, _SRCB, 0, (_te,), ((3, 1),)) + +SEARCH_RESULT_CONTENT_BLOCKS: StaticSchema = ( + 16, + n0, + _SRCBe, + 0, + (_me,), + ((SEARCH_RESULT_CONTENT_BLOCK, 0),), +) + +SEARCH_RESULT_BLOCK: StaticSchema = ( + 18, + n0, + _SRB, + 0, + (_so, _ti, _co, _ci), + ((3, 1), (3, 1), (SEARCH_RESULT_CONTENT_BLOCKS, 1), (CITATIONS_CONFIG, 0)), +) + +TOOL_REFERENCE: StaticSchema = ( + 18, + n0, + _TR, + 0, + (_ty, _n, _sN), + ((3, 0), (3, 0), (3, 0)), +) + +TOOL_ADDITION_BLOCK: StaticSchema = (18, n0, _TAB, 0, (_too,), ((TOOL_REFERENCE, 1),)) + +TOOL_REMOVAL_BLOCK: StaticSchema = (18, n0, _TRB, 0, (_too,), ((TOOL_REFERENCE, 1),)) + +VIDEO_FORMAT: StaticSchema = ( + 14, + n0, + _VF, + 0, + (_MKV, _MOV, _MP_, _WEBM, _FLV, _MPEG, _MPG, _WMV, _TG), + ((-1, 0), (-1, 0), (-1, 0), (-1, 0), (-1, 0), (-1, 0), (-1, 0), (-1, 0), (-1, 0)), +) + +VIDEO_SOURCE: StaticSchema = (19, n0, _VS, 0, (_b, _sLo), ((1, 0), (S3_LOCATION, 0))) + +VIDEO_BLOCK: StaticSchema = ( + 18, + n0, + _VB, + 0, + (_f, _so), + ((VIDEO_FORMAT, 1), (VIDEO_SOURCE, 1)), +) + +TOOL_RESULT_CONTENT_BLOCK: StaticSchema = ( + 19, + n0, + _TRCB, + 0, + (_j, _te, _i, _doc, _vi, _sRe), + ( + (13, 0), + (3, 0), + (IMAGE_BLOCK, 0), + (DOCUMENT_BLOCK, 0), + (VIDEO_BLOCK, 0), + (SEARCH_RESULT_BLOCK, 0), + ), ) -GUARDRAIL_SENSITIVE_INFORMATION_POLICY_ASSESSMENT = Schema.collection( - id=ShapeID( - "com.amazonaws.bedrockruntime#GuardrailSensitiveInformationPolicyAssessment" +TOOL_RESULT_CONTENT_BLOCKS: StaticSchema = ( + 16, + n0, + _TRCBo, + 0, + (_me,), + ((TOOL_RESULT_CONTENT_BLOCK, 0),), +) + +TOOL_RESULT_STATUS: StaticSchema = ( + 14, + n0, + _TRS, + 0, + (_SUCCESS, _ERROR), + ((-1, 0), (-1, 0)), +) + +TOOL_USE_ID: StaticSchema = (3, n0, _TUI, 0) + +TOOL_RESULT_BLOCK: StaticSchema = ( + 18, + n0, + _TRBo, + 0, + (_tUI, _co, _st, _ty), + ( + (TOOL_USE_ID, 1), + (TOOL_RESULT_CONTENT_BLOCKS, 1), + (TOOL_RESULT_STATUS, 0), + (3, 0), ), - members={ - "piiEntities": { - "target": GUARDRAIL_PII_ENTITY_FILTER_LIST, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - "regexes": { - "target": GUARDRAIL_REGEX_FILTER_LIST, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - }, ) -GUARDRAIL_TOPIC_POLICY_ACTION = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#GuardrailTopicPolicyAction"), - shape_type=ShapeType.ENUM, - members={"BLOCKED": {"target": UNIT}, "NONE": {"target": UNIT}}, -) - -GUARDRAIL_TOPIC_TYPE = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#GuardrailTopicType"), - shape_type=ShapeType.ENUM, - members={"DENY": {"target": UNIT}}, -) - -GUARDRAIL_TOPIC = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#GuardrailTopic"), - members={ - "name": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - "type": { - "target": GUARDRAIL_TOPIC_TYPE, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - "action": { - "target": GUARDRAIL_TOPIC_POLICY_ACTION, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - "detected": {"target": BOOLEAN}, - }, +TOOL_NAME: StaticSchema = (3, n0, _TN, 0) + +TOOL_USE_TYPE: StaticSchema = (14, n0, _TUT, 0, (_STU,), ((-1, 0),)) + +TOOL_USE_BLOCK: StaticSchema = ( + 18, + n0, + _TUB, + 0, + (_tUI, _n, _inp, _ty), + ((TOOL_USE_ID, 1), (TOOL_NAME, 1), (13, 1), (TOOL_USE_TYPE, 0)), +) + +CONTENT_BLOCK: StaticSchema = ( + 19, + n0, + _CB, + 0, + (_te, _i, _doc, _vi, _au, _tUo, _tR, _gCu, _cPa, _rCe, _cC, _sRe, _tAo, _tRo), + ( + (3, 0), + (IMAGE_BLOCK, 0), + (DOCUMENT_BLOCK, 0), + (VIDEO_BLOCK, 0), + (AUDIO_BLOCK, 0), + (TOOL_USE_BLOCK, 0), + (TOOL_RESULT_BLOCK, 0), + (GUARDRAIL_CONVERSE_CONTENT_BLOCK, 0), + (CACHE_POINT_BLOCK, 0), + (REASONING_CONTENT_BLOCK, 0), + (CITATIONS_CONTENT_BLOCK, 0), + (SEARCH_RESULT_BLOCK, 0), + (TOOL_ADDITION_BLOCK, 0), + (TOOL_REMOVAL_BLOCK, 0), + ), ) -GUARDRAIL_TOPIC_LIST = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#GuardrailTopicList"), - shape_type=ShapeType.LIST, - members={"member": {"target": GUARDRAIL_TOPIC}}, -) +CONTENT_BLOCKS: StaticSchema = (16, n0, _CBo, 0, (_me,), ((CONTENT_BLOCK, 0),)) -GUARDRAIL_TOPIC_POLICY_ASSESSMENT = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#GuardrailTopicPolicyAssessment"), - members={ - "topics": { - "target": GUARDRAIL_TOPIC_LIST, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - } - }, +CONVERSATION_ROLE: StaticSchema = ( + 14, + n0, + _CR, + 0, + (_USER, _ASSISTANT, _SYSTEM), + ((-1, 0), (-1, 0), (-1, 0)), ) -GUARDRAIL_WORD_POLICY_ACTION = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#GuardrailWordPolicyAction"), - shape_type=ShapeType.ENUM, - members={"BLOCKED": {"target": UNIT}, "NONE": {"target": UNIT}}, -) - -GUARDRAIL_CUSTOM_WORD = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#GuardrailCustomWord"), - members={ - "match": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - "action": { - "target": GUARDRAIL_WORD_POLICY_ACTION, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - "detected": {"target": BOOLEAN}, - }, +MESSAGE: StaticSchema = ( + 18, + n0, + _M, + 0, + (_ro, _co), + ((CONVERSATION_ROLE, 1), (CONTENT_BLOCKS, 1)), ) -GUARDRAIL_CUSTOM_WORD_LIST = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#GuardrailCustomWordList"), - shape_type=ShapeType.LIST, - members={"member": {"target": GUARDRAIL_CUSTOM_WORD}}, -) - -GUARDRAIL_MANAGED_WORD_TYPE = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#GuardrailManagedWordType"), - shape_type=ShapeType.ENUM, - members={"PROFANITY": {"target": UNIT}}, -) - -GUARDRAIL_MANAGED_WORD = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#GuardrailManagedWord"), - members={ - "match": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - "type": { - "target": GUARDRAIL_MANAGED_WORD_TYPE, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - "action": { - "target": GUARDRAIL_WORD_POLICY_ACTION, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - "detected": {"target": BOOLEAN}, - }, -) +MESSAGES: StaticSchema = (16, n0, _Me, 0, (_me,), ((MESSAGE, 0),)) -GUARDRAIL_MANAGED_WORD_LIST = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#GuardrailManagedWordList"), - shape_type=ShapeType.LIST, - members={"member": {"target": GUARDRAIL_MANAGED_WORD}}, -) +CONVERSATIONAL_MODEL_ID: StaticSchema = (3, n0, _CMI, 0) -GUARDRAIL_WORD_POLICY_ASSESSMENT = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#GuardrailWordPolicyAssessment"), - members={ - "customWords": { - "target": GUARDRAIL_CUSTOM_WORD_LIST, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - "managedWordLists": { - "target": GUARDRAIL_MANAGED_WORD_LIST, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - }, +JSON_SCHEMA_DEFINITION: StaticSchema = ( + 18, + n0, + _JSD, + 0, + (_sch, _n, _de), + ((3, 1), (3, 0), (3, 0)), ) -GUARDRAIL_ASSESSMENT = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#GuardrailAssessment"), - members={ - "topicPolicy": {"target": GUARDRAIL_TOPIC_POLICY_ASSESSMENT}, - "contentPolicy": {"target": GUARDRAIL_CONTENT_POLICY_ASSESSMENT}, - "wordPolicy": {"target": GUARDRAIL_WORD_POLICY_ASSESSMENT}, - "sensitiveInformationPolicy": { - "target": GUARDRAIL_SENSITIVE_INFORMATION_POLICY_ASSESSMENT - }, - "contextualGroundingPolicy": { - "target": GUARDRAIL_CONTEXTUAL_GROUNDING_POLICY_ASSESSMENT - }, - "automatedReasoningPolicy": { - "target": GUARDRAIL_AUTOMATED_REASONING_POLICY_ASSESSMENT - }, - "invocationMetrics": {"target": GUARDRAIL_INVOCATION_METRICS}, - "appliedGuardrailDetails": {"target": APPLIED_GUARDRAIL_DETAILS}, - }, +OUTPUT_FORMAT_STRUCTURE: StaticSchema = ( + 19, + n0, + _OFS, + 4, + (_jS,), + ((JSON_SCHEMA_DEFINITION, 0),), ) -GUARDRAIL_ASSESSMENT_LIST = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#GuardrailAssessmentList"), - shape_type=ShapeType.LIST, - members={"member": {"target": GUARDRAIL_ASSESSMENT}}, -) +OUTPUT_FORMAT_TYPE: StaticSchema = (14, n0, _OFT, 0, (_JS,), ((-1, 0),)) -GUARDRAIL_OUTPUT_TEXT = Schema( - id=ShapeID("com.amazonaws.bedrockruntime#GuardrailOutputText"), - shape_type=ShapeType.STRING, +OUTPUT_FORMAT: StaticSchema = ( + 18, + n0, + _OF, + 0, + (_ty, _str), + ((OUTPUT_FORMAT_TYPE, 1), (OUTPUT_FORMAT_STRUCTURE, 1)), ) -GUARDRAIL_OUTPUT_CONTENT = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#GuardrailOutputContent"), - members={"text": {"target": GUARDRAIL_OUTPUT_TEXT}}, -) +OUTPUT_CONFIG: StaticSchema = (18, n0, _OC, 0, (_tF, _ef), ((OUTPUT_FORMAT, 0), (3, 0))) -GUARDRAIL_OUTPUT_CONTENT_LIST = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#GuardrailOutputContentList"), - shape_type=ShapeType.LIST, - members={"member": {"target": GUARDRAIL_OUTPUT_CONTENT}}, +PERFORMANCE_CONFIG_LATENCY: StaticSchema = ( + 14, + n0, + _PCL, + 0, + (_STANDARD, _OPTIMIZED), + ((-1, 0), (-1, 0)), ) -APPLY_GUARDRAIL_OUTPUT = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#ApplyGuardrailOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="com.amazonaws.bedrockruntime#ApplyGuardrailResponse", - ) - ], - members={ - "usage": { - "target": GUARDRAIL_USAGE, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - "action": { - "target": GUARDRAIL_ACTION, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - "actionReason": {"target": STRING}, - "outputs": { - "target": GUARDRAIL_OUTPUT_CONTENT_LIST, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - "assessments": { - "target": GUARDRAIL_ASSESSMENT_LIST, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - "guardrailCoverage": {"target": GUARDRAIL_COVERAGE}, - }, +PERFORMANCE_CONFIGURATION: StaticSchema = ( + 18, + n0, + _PC, + 0, + (_la,), + ((PERFORMANCE_CONFIG_LATENCY, {_smith: _stan}),), ) -APPLY_GUARDRAIL = Schema( - id=ShapeID("com.amazonaws.bedrockruntime#ApplyGuardrail"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType( - { - "code": 200, - "method": "POST", - "uri": "/guardrail/{guardrailIdentifier}/version/{guardrailVersion}/apply", - } - ), - ) - ], -) - -GUARDRAIL_CHECKS_CONTENT_FILTER_CATEGORY = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#GuardrailChecksContentFilterCategory"), - shape_type=ShapeType.ENUM, - members={ - "VIOLENCE": {"target": UNIT}, - "HATE": {"target": UNIT}, - "SEXUAL": {"target": UNIT}, - "MISCONDUCT": {"target": UNIT}, - "INSULTS": {"target": UNIT}, - }, -) +PROMPT_VARIABLE_VALUES: StaticSchema = (19, n0, _PVV, 0, (_te,), ((3, 0),)) -GUARDRAIL_CHECKS_CONTENT_FILTER_CATEGORY_CONFIG = Schema.collection( - id=ShapeID( - "com.amazonaws.bedrockruntime#GuardrailChecksContentFilterCategoryConfig" - ), - members={ - "category": { - "target": GUARDRAIL_CHECKS_CONTENT_FILTER_CATEGORY, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - } - }, +PROMPT_VARIABLE_MAP: StaticSchema = ( + 17, + n0, + _PVM, + 4, + (_k, _v), + ((3, 0), (PROMPT_VARIABLE_VALUES, 0)), ) -GUARDRAIL_CHECKS_CONTENT_FILTER_CATEGORY_CONFIG_LIST = Schema.collection( - id=ShapeID( - "com.amazonaws.bedrockruntime#GuardrailChecksContentFilterCategoryConfigList" - ), - shape_type=ShapeType.LIST, - members={"member": {"target": GUARDRAIL_CHECKS_CONTENT_FILTER_CATEGORY_CONFIG}}, -) +REQUEST_METADATA: StaticSchema = (17, n0, _RM, 4, (_k, _v), ((3, 0), (3, 0))) -GUARDRAIL_CHECKS_CONTENT_FILTER_CONFIG = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#GuardrailChecksContentFilterConfig"), - members={ - "categories": { - "target": GUARDRAIL_CHECKS_CONTENT_FILTER_CATEGORY_CONFIG_LIST, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - } - }, +SERVICE_TIER_TYPE: StaticSchema = ( + 14, + n0, + _STT, + 0, + (_PRIORITY, _DEFAULT, _FLEX, _RESERVED), + ((-1, 0), (-1, 0), (-1, 0), (-1, 0)), ) -GUARDRAIL_CHECKS_PROMPT_ATTACK_CATEGORY = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#GuardrailChecksPromptAttackCategory"), - shape_type=ShapeType.ENUM, - members={ - "JAILBREAK": {"target": UNIT}, - "PROMPT_INJECTION": {"target": UNIT}, - "PROMPT_LEAKAGE": {"target": UNIT}, - }, -) +SERVICE_TIER: StaticSchema = (18, n0, _STe, 0, (_ty,), ((SERVICE_TIER_TYPE, 1),)) -GUARDRAIL_CHECKS_PROMPT_ATTACK_CATEGORY_CONFIG = Schema.collection( - id=ShapeID( - "com.amazonaws.bedrockruntime#GuardrailChecksPromptAttackCategoryConfig" +SYSTEM_CONTENT_BLOCK: StaticSchema = ( + 19, + n0, + _SCB, + 0, + (_te, _gCu, _cPa), + ( + (NON_EMPTY_STRING, 0), + (GUARDRAIL_CONVERSE_CONTENT_BLOCK, 0), + (CACHE_POINT_BLOCK, 0), ), - members={ - "category": { - "target": GUARDRAIL_CHECKS_PROMPT_ATTACK_CATEGORY, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - } - }, ) -GUARDRAIL_CHECKS_PROMPT_ATTACK_CATEGORY_CONFIG_LIST = Schema.collection( - id=ShapeID( - "com.amazonaws.bedrockruntime#GuardrailChecksPromptAttackCategoryConfigList" +SYSTEM_CONTENT_BLOCKS: StaticSchema = ( + 16, + n0, + _SCBy, + 0, + (_me,), + ((SYSTEM_CONTENT_BLOCK, 0),), +) + +ANY_TOOL_CHOICE: StaticSchema = (18, n0, _ATC, 0) + +AUTO_TOOL_CHOICE: StaticSchema = (18, n0, _ATCu, 0) + +SPECIFIC_TOOL_CHOICE: StaticSchema = (18, n0, _STC, 0, (_n,), ((TOOL_NAME, 1),)) + +TOOL_CHOICE: StaticSchema = ( + 19, + n0, + _TC, + 0, + (_aut, _an, _too), + ((AUTO_TOOL_CHOICE, 0), (ANY_TOOL_CHOICE, 0), (SPECIFIC_TOOL_CHOICE, 0)), +) + +SYSTEM_TOOL: StaticSchema = (18, n0, _STy, 0, (_n,), ((TOOL_NAME, 1),)) + +TOOL_INPUT_SCHEMA: StaticSchema = (19, n0, _TIS, 0, (_j,), ((13, 0),)) + +TOOL_SPECIFICATION: StaticSchema = ( + 18, + n0, + _TS, + 0, + (_n, _de, _iS, _stri), + ((TOOL_NAME, 1), (NON_EMPTY_STRING, 0), (TOOL_INPUT_SCHEMA, 1), (2, 0)), +) + +TOOL: StaticSchema = ( + 19, + n0, + _To, + 0, + (_tS, _sTy, _cPa), + ((TOOL_SPECIFICATION, 0), (SYSTEM_TOOL, 0), (CACHE_POINT_BLOCK, 0)), +) + +TOOLS: StaticSchema = (16, n0, _Too, 0, (_me,), ((TOOL, 0),)) + +TOOL_CONFIGURATION: StaticSchema = ( + 18, + n0, + _TCo, + 0, + (_tool, _tCo), + ((TOOLS, 1), (TOOL_CHOICE, 0)), +) + +CONVERSE_INPUT: StaticSchema = ( + 18, + n0, + _CI, + {_sSI: _cCR}, + (_mI, _mes, _sy, _iC, _tCoo, _gCua, _aMRF, _pV, _aMRFP, _rM, _pC, _sTe, _oC), + ( + (CONVERSATIONAL_MODEL_ID, 9), + (MESSAGES, 0), + (SYSTEM_CONTENT_BLOCKS, 0), + (INFERENCE_CONFIGURATION, 0), + (TOOL_CONFIGURATION, 0), + (GUARDRAIL_CONFIGURATION, 0), + (13, 0), + (PROMPT_VARIABLE_MAP, 0), + (ADDITIONAL_MODEL_RESPONSE_FIELD_PATHS, 0), + (REQUEST_METADATA, 0), + (PERFORMANCE_CONFIGURATION, 0), + (SERVICE_TIER, 0), + (OUTPUT_CONFIG, 0), ), - shape_type=ShapeType.LIST, - members={"member": {"target": GUARDRAIL_CHECKS_PROMPT_ATTACK_CATEGORY_CONFIG}}, ) -GUARDRAIL_CHECKS_PROMPT_ATTACK_CONFIG = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#GuardrailChecksPromptAttackConfig"), - members={ - "categories": { - "target": GUARDRAIL_CHECKS_PROMPT_ATTACK_CATEGORY_CONFIG_LIST, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - } - }, -) +CONVERSE_METRICS: StaticSchema = (18, n0, _CM, 0, (_lM,), ((8, 1),)) -GUARDRAIL_CHECKS_SENSITIVE_INFORMATION_ENTITY_TYPE = Schema.collection( - id=ShapeID( - "com.amazonaws.bedrockruntime#GuardrailChecksSensitiveInformationEntityType" - ), - shape_type=ShapeType.ENUM, - members={ - "ADDRESS": {"target": UNIT}, - "AGE": {"target": UNIT}, - "AWS_ACCESS_KEY": {"target": UNIT}, - "AWS_SECRET_KEY": {"target": UNIT}, - "CA_HEALTH_NUMBER": {"target": UNIT}, - "CA_SOCIAL_INSURANCE_NUMBER": {"target": UNIT}, - "CREDIT_DEBIT_CARD_CVV": {"target": UNIT}, - "CREDIT_DEBIT_CARD_EXPIRY": {"target": UNIT}, - "CREDIT_DEBIT_CARD_NUMBER": {"target": UNIT}, - "DRIVER_ID": {"target": UNIT}, - "EMAIL": {"target": UNIT}, - "INTERNATIONAL_BANK_ACCOUNT_NUMBER": {"target": UNIT}, - "IP_ADDRESS": {"target": UNIT}, - "LICENSE_PLATE": {"target": UNIT}, - "MAC_ADDRESS": {"target": UNIT}, - "NAME": {"target": UNIT}, - "PASSWORD": {"target": UNIT}, - "PHONE": {"target": UNIT}, - "PIN": {"target": UNIT}, - "SWIFT_CODE": {"target": UNIT}, - "UK_NATIONAL_HEALTH_SERVICE_NUMBER": {"target": UNIT}, - "UK_NATIONAL_INSURANCE_NUMBER": {"target": UNIT}, - "UK_UNIQUE_TAXPAYER_REFERENCE_NUMBER": {"target": UNIT}, - "URL": {"target": UNIT}, - "USERNAME": {"target": UNIT}, - "US_BANK_ACCOUNT_NUMBER": {"target": UNIT}, - "US_BANK_ROUTING_NUMBER": {"target": UNIT}, - "US_INDIVIDUAL_TAX_IDENTIFICATION_NUMBER": {"target": UNIT}, - "US_PASSPORT_NUMBER": {"target": UNIT}, - "US_SOCIAL_SECURITY_NUMBER": {"target": UNIT}, - "VEHICLE_IDENTIFICATION_NUMBER": {"target": UNIT}, - }, -) +CONVERSE_OUTPUT: StaticSchema = (19, n0, _CO, 0, (_m,), ((MESSAGE, 0),)) -GUARDRAIL_CHECKS_SENSITIVE_INFORMATION_ENTITY_CONFIG = Schema.collection( - id=ShapeID( - "com.amazonaws.bedrockruntime#GuardrailChecksSensitiveInformationEntityConfig" - ), - members={ - "type": { - "target": GUARDRAIL_CHECKS_SENSITIVE_INFORMATION_ENTITY_TYPE, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - } - }, +STOP_REASON: StaticSchema = ( + 14, + n0, + _SR, + 0, + (_ET, _TU, _MT, _SS, _GI_, _CF, _MMO, _MTU, _MCWE), + ((-1, 0), (-1, 0), (-1, 0), (-1, 0), (-1, 0), (-1, 0), (-1, 0), (-1, 0), (-1, 0)), ) -GUARDRAIL_CHECKS_SENSITIVE_INFORMATION_ENTITY_CONFIG_LIST = Schema.collection( - id=ShapeID( - "com.amazonaws.bedrockruntime#GuardrailChecksSensitiveInformationEntityConfigList" - ), - shape_type=ShapeType.LIST, - members={ - "member": {"target": GUARDRAIL_CHECKS_SENSITIVE_INFORMATION_ENTITY_CONFIG} - }, +GUARDRAIL_ASSESSMENT_MAP: StaticSchema = ( + 17, + n0, + _GAM, + 0, + (_k, _v), + ((3, 0), (GUARDRAIL_ASSESSMENT, 0)), ) -GUARDRAIL_CHECKS_SENSITIVE_INFORMATION_CONFIG = Schema.collection( - id=ShapeID( - "com.amazonaws.bedrockruntime#GuardrailChecksSensitiveInformationConfig" - ), - members={ - "entities": { - "target": GUARDRAIL_CHECKS_SENSITIVE_INFORMATION_ENTITY_CONFIG_LIST, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - } - }, -) +MODEL_OUTPUTS: StaticSchema = (16, n0, _MO, 0, (_me,), ((GUARDRAIL_OUTPUT_TEXT, 0),)) -GUARDRAIL_CHECKS_CONFIG = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#GuardrailChecksConfig"), - members={ - "contentFilter": {"target": GUARDRAIL_CHECKS_CONTENT_FILTER_CONFIG}, - "promptAttack": {"target": GUARDRAIL_CHECKS_PROMPT_ATTACK_CONFIG}, - "sensitiveInformation": { - "target": GUARDRAIL_CHECKS_SENSITIVE_INFORMATION_CONFIG - }, - }, +GUARDRAIL_ASSESSMENT_LIST_MAP: StaticSchema = ( + 17, + n0, + _GALM, + 0, + (_k, _v), + ((3, 0), (GUARDRAIL_ASSESSMENT_LIST, 0)), ) -GUARDRAIL_CHECKS_TEXT_CONTENT = Schema( - id=ShapeID("com.amazonaws.bedrockruntime#GuardrailChecksTextContent"), - shape_type=ShapeType.STRING, - traits=[Trait.new(id=ShapeID("smithy.api#sensitive"))], +GUARDRAIL_TRACE_ASSESSMENT: StaticSchema = ( + 18, + n0, + _GTA, + 0, + (_mO, _iAn, _oA, _aR), + ( + (MODEL_OUTPUTS, 0), + (GUARDRAIL_ASSESSMENT_MAP, 0), + (GUARDRAIL_ASSESSMENT_LIST_MAP, 0), + (3, 0), + ), ) -GUARDRAIL_CHECKS_CONTENT_BLOCK = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#GuardrailChecksContentBlock"), - shape_type=ShapeType.UNION, - members={"text": {"target": GUARDRAIL_CHECKS_TEXT_CONTENT}}, -) +INVOKED_MODEL_ID: StaticSchema = (3, n0, _IMI, 0) -GUARDRAIL_CHECKS_CONTENT_BLOCK_LIST = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#GuardrailChecksContentBlockList"), - shape_type=ShapeType.LIST, - members={"member": {"target": GUARDRAIL_CHECKS_CONTENT_BLOCK}}, -) +PROMPT_ROUTER_TRACE: StaticSchema = (18, n0, _PRT, 0, (_iMI,), ((INVOKED_MODEL_ID, 0),)) -GUARDRAIL_CHECKS_ROLE = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#GuardrailChecksRole"), - shape_type=ShapeType.ENUM, - members={ - "USER": {"target": UNIT}, - "ASSISTANT": {"target": UNIT}, - "SYSTEM": {"target": UNIT}, - }, +CONVERSE_TRACE: StaticSchema = ( + 18, + n0, + _CT, + 0, + (_gu, _pR), + ((GUARDRAIL_TRACE_ASSESSMENT, 0), (PROMPT_ROUTER_TRACE, 0)), ) -GUARDRAIL_CHECKS_MESSAGE = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#GuardrailChecksMessage"), - members={ - "role": { - "target": GUARDRAIL_CHECKS_ROLE, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - "content": { - "target": GUARDRAIL_CHECKS_CONTENT_BLOCK_LIST, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - }, -) +CACHE_DETAIL: StaticSchema = (18, n0, _CD, 0, (_tt, _iT), ((CACHE_TTL, 1), (7, 1))) -GUARDRAIL_CHECKS_MESSAGE_LIST = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#GuardrailChecksMessageList"), - shape_type=ShapeType.LIST, - members={"member": {"target": GUARDRAIL_CHECKS_MESSAGE}}, -) +CACHE_DETAILS_LIST: StaticSchema = (16, n0, _CDL, 0, (_me,), ((CACHE_DETAIL, 0),)) -INVOKE_GUARDRAIL_CHECKS_INPUT = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#InvokeGuardrailChecksInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="com.amazonaws.bedrockruntime#InvokeGuardrailChecksRequest", - ) - ], - members={ - "messages": { - "target": GUARDRAIL_CHECKS_MESSAGE_LIST, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - "checks": { - "target": GUARDRAIL_CHECKS_CONFIG, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - }, +TOKEN_USAGE: StaticSchema = ( + 18, + n0, + _TUo, + 0, + (_iT, _oT, _tT, _cRIT, _cWIT, _cD), + ((7, 1), (7, 1), (7, 1), (7, 0), (7, 0), (CACHE_DETAILS_LIST, 0)), ) -GUARDRAIL_CHECKS_CONTENT_FILTER_RESULT_ENTRY = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#GuardrailChecksContentFilterResultEntry"), - members={ - "category": { - "target": GUARDRAIL_CHECKS_CONTENT_FILTER_CATEGORY, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - "severityScore": { - "target": DOUBLE, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - }, +CONVERSE_OPERATION_OUTPUT: StaticSchema = ( + 18, + n0, + _COO, + {_sSI: _cCRo}, + (_out, _sRt, _u, _met, _aMRFd, _trac, _pC, _sTe), + ( + (CONVERSE_OUTPUT, 1), + (STOP_REASON, 1), + (TOKEN_USAGE, 1), + (CONVERSE_METRICS, 1), + (13, 0), + (CONVERSE_TRACE, 0), + (PERFORMANCE_CONFIGURATION, 0), + (SERVICE_TIER, 0), + ), ) -GUARDRAIL_CHECKS_CONTENT_FILTER_RESULT_LIST = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#GuardrailChecksContentFilterResultList"), - shape_type=ShapeType.LIST, - members={"member": {"target": GUARDRAIL_CHECKS_CONTENT_FILTER_RESULT_ENTRY}}, -) +STATUS_CODE: StaticSchema = (7, n0, _SCt, 0) -GUARDRAIL_CHECKS_CONTENT_FILTER_RESULT = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#GuardrailChecksContentFilterResult"), - members={ - "results": { - "target": GUARDRAIL_CHECKS_CONTENT_FILTER_RESULT_LIST, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - } - }, +MODEL_ERROR_EXCEPTION: StaticSchema = ( + 18, + n0, + _MEE, + {_s: _c, _sE: 424}, + (_m, _oSC, _rN), + ((NON_BLANK_STRING, 0), (STATUS_CODE, 0), (NON_BLANK_STRING, 0)), ) -GUARDRAIL_CHECKS_PROMPT_ATTACK_RESULT_ENTRY = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#GuardrailChecksPromptAttackResultEntry"), - members={ - "category": { - "target": GUARDRAIL_CHECKS_PROMPT_ATTACK_CATEGORY, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - "severityScore": { - "target": DOUBLE, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - }, +MODEL_NOT_READY_EXCEPTION: StaticSchema = ( + 18, + n0, + _MNRE, + {_s: _c, _sE: 429}, + (_m,), + ((NON_BLANK_STRING, 0),), ) -GUARDRAIL_CHECKS_PROMPT_ATTACK_RESULT_LIST = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#GuardrailChecksPromptAttackResultList"), - shape_type=ShapeType.LIST, - members={"member": {"target": GUARDRAIL_CHECKS_PROMPT_ATTACK_RESULT_ENTRY}}, +MODEL_TIMEOUT_EXCEPTION: StaticSchema = ( + 18, + n0, + _MTE, + {_s: _c, _sE: 408}, + (_m,), + ((NON_BLANK_STRING, 0),), ) -GUARDRAIL_CHECKS_PROMPT_ATTACK_RESULT = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#GuardrailChecksPromptAttackResult"), - members={ - "results": { - "target": GUARDRAIL_CHECKS_PROMPT_ATTACK_RESULT_LIST, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - } +CONVERSE: StaticOperationSchema = ( + 23, + n0, + _Co, + { + _smit: MappingProxyType( + {"code": 200, "method": "POST", "uri": "/model/{modelId}/converse"} + ) }, -) - -GUARDRAIL_CHECKS_SENSITIVE_INFORMATION_RESULT_ENTRY = Schema.collection( - id=ShapeID( - "com.amazonaws.bedrockruntime#GuardrailChecksSensitiveInformationResultEntry" + CONVERSE_INPUT, + CONVERSE_OPERATION_OUTPUT, + ( + ACCESS_DENIED_EXCEPTION, + INTERNAL_SERVER_EXCEPTION, + MODEL_ERROR_EXCEPTION, + MODEL_NOT_READY_EXCEPTION, + MODEL_TIMEOUT_EXCEPTION, + RESOURCE_NOT_FOUND_EXCEPTION, + SERVICE_UNAVAILABLE_EXCEPTION, + THROTTLING_EXCEPTION, + VALIDATION_EXCEPTION, ), - members={ - "type": { - "target": GUARDRAIL_CHECKS_SENSITIVE_INFORMATION_ENTITY_TYPE, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - "confidenceScore": { - "target": DOUBLE, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - "beginOffset": { - "target": INTEGER, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - "endOffset": { - "target": INTEGER, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - "messageIndex": { - "target": INTEGER, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - "contentIndex": { - "target": INTEGER, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - }, ) -GUARDRAIL_CHECKS_SENSITIVE_INFORMATION_RESULT_LIST = Schema.collection( - id=ShapeID( - "com.amazonaws.bedrockruntime#GuardrailChecksSensitiveInformationResultList" +GUARDRAIL_STREAM_PROCESSING_MODE: StaticSchema = ( + 14, + n0, + _GSPM, + 0, + (_SYNC, _ASYNC), + ((-1, 0), (-1, 0)), +) + +GUARDRAIL_STREAM_CONFIGURATION: StaticSchema = ( + 18, + n0, + _GSC, + 0, + (_gI, _gV, _trac, _sPM), + ( + (GUARDRAIL_IDENTIFIER, {_smith: _v_}), + (GUARDRAIL_VERSION, {_smith: _v_}), + (GUARDRAIL_TRACE, {_smith: _di}), + (GUARDRAIL_STREAM_PROCESSING_MODE, {_smith: _syn}), ), - shape_type=ShapeType.LIST, - members={"member": {"target": GUARDRAIL_CHECKS_SENSITIVE_INFORMATION_RESULT_ENTRY}}, ) -GUARDRAIL_CHECKS_SENSITIVE_INFORMATION_RESULT = Schema.collection( - id=ShapeID( - "com.amazonaws.bedrockruntime#GuardrailChecksSensitiveInformationResult" +CONVERSE_STREAM_INPUT: StaticSchema = ( + 18, + n0, + _CSI, + {_sSI: _cCSR}, + (_mI, _mes, _sy, _iC, _tCoo, _gCua, _aMRF, _pV, _aMRFP, _rM, _pC, _sTe, _oC), + ( + (CONVERSATIONAL_MODEL_ID, 9), + (MESSAGES, 0), + (SYSTEM_CONTENT_BLOCKS, 0), + (INFERENCE_CONFIGURATION, 0), + (TOOL_CONFIGURATION, 0), + (GUARDRAIL_STREAM_CONFIGURATION, 0), + (13, 0), + (PROMPT_VARIABLE_MAP, 0), + (ADDITIONAL_MODEL_RESPONSE_FIELD_PATHS, 0), + (REQUEST_METADATA, 0), + (PERFORMANCE_CONFIGURATION, 0), + (SERVICE_TIER, 0), + (OUTPUT_CONFIG, 0), ), - members={ - "results": { - "target": GUARDRAIL_CHECKS_SENSITIVE_INFORMATION_RESULT_LIST, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - "truncated": {"target": BOOLEAN}, - }, -) - -GUARDRAIL_CHECKS_RESULTS = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#GuardrailChecksResults"), - members={ - "contentFilter": {"target": GUARDRAIL_CHECKS_CONTENT_FILTER_RESULT}, - "promptAttack": {"target": GUARDRAIL_CHECKS_PROMPT_ATTACK_RESULT}, - "sensitiveInformation": { - "target": GUARDRAIL_CHECKS_SENSITIVE_INFORMATION_RESULT - }, - }, -) - -GUARDRAIL_CHECKS_CONTENT_FILTER_USAGE = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#GuardrailChecksContentFilterUsage"), - members={ - "textUnits": { - "target": INTEGER, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - } - }, ) -GUARDRAIL_CHECKS_PROMPT_ATTACK_USAGE = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#GuardrailChecksPromptAttackUsage"), - members={ - "textUnits": { - "target": INTEGER, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - } - }, +NON_NEGATIVE_INTEGER: StaticSchema = (7, n0, _NNI, 0) + +CITATION_SOURCE_CONTENT_DELTA: StaticSchema = (18, n0, _CSCD, 0, (_te,), ((3, 0),)) + +CITATION_SOURCE_CONTENT_LIST_DELTA: StaticSchema = ( + 16, + n0, + _CSCLD, + 0, + (_me,), + ((CITATION_SOURCE_CONTENT_DELTA, 0),), +) + +CITATIONS_DELTA: StaticSchema = ( + 18, + n0, + _CDi, + 0, + (_ti, _so, _sC, _lo), + ((3, 0), (3, 0), (CITATION_SOURCE_CONTENT_LIST_DELTA, 0), (CITATION_LOCATION, 0)), +) + +IMAGE_BLOCK_DELTA: StaticSchema = ( + 18, + n0, + _IBD, + 0, + (_so, _er), + ((IMAGE_SOURCE, 0), (ERROR_BLOCK, 0)), +) + +REASONING_CONTENT_BLOCK_DELTA: StaticSchema = ( + 19, + n0, + _RCBD, + 4, + (_te, _rC, _si), + ((3, 0), (1, 0), (3, 0)), +) + +TOOL_RESULT_BLOCK_DELTA: StaticSchema = (19, n0, _TRBD, 0, (_te, _j), ((3, 0), (13, 0))) + +TOOL_RESULT_BLOCKS_DELTA: StaticSchema = ( + 16, + n0, + _TRBDo, + 0, + (_me,), + ((TOOL_RESULT_BLOCK_DELTA, 0),), +) + +TOOL_USE_BLOCK_DELTA: StaticSchema = (18, n0, _TUBD, 0, (_inp,), ((3, 1),)) + +CONTENT_BLOCK_DELTA: StaticSchema = ( + 19, + n0, + _CBD, + 0, + (_te, _tUo, _tR, _rCe, _cit, _i), + ( + (3, 0), + (TOOL_USE_BLOCK_DELTA, 0), + (TOOL_RESULT_BLOCKS_DELTA, 0), + (REASONING_CONTENT_BLOCK_DELTA, 0), + (CITATIONS_DELTA, 0), + (IMAGE_BLOCK_DELTA, 0), + ), ) -GUARDRAIL_CHECKS_SENSITIVE_INFORMATION_USAGE = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#GuardrailChecksSensitiveInformationUsage"), - members={ - "textUnits": { - "target": INTEGER, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - } - }, +CONTENT_BLOCK_DELTA_EVENT: StaticSchema = ( + 18, + n0, + _CBDE, + 0, + (_del, _cBI), + ((CONTENT_BLOCK_DELTA, 1), (NON_NEGATIVE_INTEGER, 1)), +) + +IMAGE_BLOCK_START: StaticSchema = (18, n0, _IBS, 0, (_f,), ((IMAGE_FORMAT, 1),)) + +TOOL_RESULT_BLOCK_START: StaticSchema = ( + 18, + n0, + _TRBS, + 0, + (_tUI, _ty, _st), + ((TOOL_USE_ID, 1), (3, 0), (TOOL_RESULT_STATUS, 0)), +) + +TOOL_USE_BLOCK_START: StaticSchema = ( + 18, + n0, + _TUBS, + 0, + (_tUI, _n, _ty), + ((TOOL_USE_ID, 1), (TOOL_NAME, 1), (TOOL_USE_TYPE, 0)), +) + +CONTENT_BLOCK_START: StaticSchema = ( + 19, + n0, + _CBS, + 0, + (_tUo, _tR, _i), + ((TOOL_USE_BLOCK_START, 0), (TOOL_RESULT_BLOCK_START, 0), (IMAGE_BLOCK_START, 0)), +) + +CONTENT_BLOCK_START_EVENT: StaticSchema = ( + 18, + n0, + _CBSE, + 0, + (_star, _cBI), + ((CONTENT_BLOCK_START, 1), (NON_NEGATIVE_INTEGER, 1)), +) + +CONTENT_BLOCK_STOP_EVENT: StaticSchema = ( + 18, + n0, + _CBSEo, + 0, + (_cBI,), + ((NON_NEGATIVE_INTEGER, 1),), +) + +MESSAGE_START_EVENT: StaticSchema = (18, n0, _MSE, 0, (_ro,), ((CONVERSATION_ROLE, 1),)) + +MESSAGE_STOP_EVENT: StaticSchema = ( + 18, + n0, + _MSEe, + 0, + (_sRt, _aMRFd), + ((STOP_REASON, 1), (13, 0)), +) + +CONVERSE_STREAM_METRICS: StaticSchema = (18, n0, _CSM, 0, (_lM,), ((8, 1),)) + +CONVERSE_STREAM_TRACE: StaticSchema = ( + 18, + n0, + _CST, + 0, + (_gu, _pR), + ((GUARDRAIL_TRACE_ASSESSMENT, 0), (PROMPT_ROUTER_TRACE, 0)), +) + +CONVERSE_STREAM_METADATA_EVENT: StaticSchema = ( + 18, + n0, + _CSME, + 0, + (_u, _met, _trac, _pC, _sTe), + ( + (TOKEN_USAGE, 1), + (CONVERSE_STREAM_METRICS, 1), + (CONVERSE_STREAM_TRACE, 0), + (PERFORMANCE_CONFIGURATION, 0), + (SERVICE_TIER, 0), + ), ) -GUARDRAIL_CHECKS_USAGE_RESULTS = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#GuardrailChecksUsageResults"), - members={ - "contentFilter": {"target": GUARDRAIL_CHECKS_CONTENT_FILTER_USAGE}, - "promptAttack": {"target": GUARDRAIL_CHECKS_PROMPT_ATTACK_USAGE}, - "sensitiveInformation": { - "target": GUARDRAIL_CHECKS_SENSITIVE_INFORMATION_USAGE - }, - }, +MODEL_STREAM_ERROR_EXCEPTION: StaticSchema = ( + 18, + n0, + _MSEE, + {_s: _c, _sE: 424}, + (_m, _oSC, _oM), + ((NON_BLANK_STRING, 0), (STATUS_CODE, 0), (NON_BLANK_STRING, 0)), +) + +CONVERSE_STREAM_OUTPUT: StaticSchema = ( + 19, + n0, + _CSO, + {_smithy: None}, + (_mS, _cBS, _cBD, _cBSo, _mSe, _meta, _iSE, _mSEE, _vE, _tE, _sUE), + ( + (MESSAGE_START_EVENT, 0), + (CONTENT_BLOCK_START_EVENT, 0), + (CONTENT_BLOCK_DELTA_EVENT, 0), + (CONTENT_BLOCK_STOP_EVENT, 0), + (MESSAGE_STOP_EVENT, 0), + (CONVERSE_STREAM_METADATA_EVENT, 0), + (INTERNAL_SERVER_EXCEPTION, 0), + (MODEL_STREAM_ERROR_EXCEPTION, 0), + (VALIDATION_EXCEPTION, 0), + (THROTTLING_EXCEPTION, 0), + (SERVICE_UNAVAILABLE_EXCEPTION, 0), + ), ) -INVOKE_GUARDRAIL_CHECKS_OUTPUT = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#InvokeGuardrailChecksOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="com.amazonaws.bedrockruntime#InvokeGuardrailChecksResponse", - ) - ], - members={ - "results": { - "target": GUARDRAIL_CHECKS_RESULTS, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - "usage": { - "target": GUARDRAIL_CHECKS_USAGE_RESULTS, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - }, +CONVERSE_STREAM_OPERATION_OUTPUT: StaticSchema = ( + 18, + n0, + _CSOO, + {_sSI: _cCSRo}, + (_stre,), + ((CONVERSE_STREAM_OUTPUT, 16),), ) -INVOKE_GUARDRAIL_CHECKS = Schema( - id=ShapeID("com.amazonaws.bedrockruntime#InvokeGuardrailChecks"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType( - {"code": 200, "method": "POST", "uri": "/guardrail-checks/invoke"} - ), +CONVERSE_STREAM: StaticOperationSchema = ( + 23, + n0, + _CS, + { + _smit: MappingProxyType( + {"code": 200, "method": "POST", "uri": "/model/{modelId}/converse-stream"} ) - ], -) - -GUARDRAIL_TRACE = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#GuardrailTrace"), - shape_type=ShapeType.ENUM, - members={ - "ENABLED": {"target": UNIT}, - "DISABLED": {"target": UNIT}, - "ENABLED_FULL": {"target": UNIT}, - }, -) - -GUARDRAIL_CONFIGURATION = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#GuardrailConfiguration"), - members={ - "guardrailIdentifier": { - "target": GUARDRAIL_IDENTIFIER, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value="")], - }, - "guardrailVersion": { - "target": GUARDRAIL_VERSION, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value="")], - }, - "trace": { - "target": GUARDRAIL_TRACE, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value="disabled")], - }, - }, -) - -NON_EMPTY_STRING = Schema( - id=ShapeID("com.amazonaws.bedrockruntime#NonEmptyString"), - shape_type=ShapeType.STRING, -) - -NON_EMPTY_STRING_LIST = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#NonEmptyStringList"), - shape_type=ShapeType.LIST, - members={"member": {"target": NON_EMPTY_STRING}}, -) - -INFERENCE_CONFIGURATION = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#InferenceConfiguration"), - members={ - "maxTokens": {"target": INTEGER}, - "temperature": {"target": FLOAT}, - "topP": {"target": FLOAT}, - "stopSequences": {"target": NON_EMPTY_STRING_LIST}, - }, -) - -ERROR_BLOCK = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#ErrorBlock"), - traits=[Trait.new(id=ShapeID("smithy.api#sensitive"))], - members={"message": {"target": STRING}}, -) - -AUDIO_FORMAT = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#AudioFormat"), - shape_type=ShapeType.ENUM, - members={ - "MP3": {"target": UNIT}, - "OPUS": {"target": UNIT}, - "WAV": {"target": UNIT}, - "AAC": {"target": UNIT}, - "FLAC": {"target": UNIT}, - "MP4": {"target": UNIT}, - "OGG": {"target": UNIT}, - "MKV": {"target": UNIT}, - "MKA": {"target": UNIT}, - "X_AAC": {"target": UNIT}, - "M4A": {"target": UNIT}, - "MPEG": {"target": UNIT}, - "MPGA": {"target": UNIT}, - "PCM": {"target": UNIT}, - "WEBM": {"target": UNIT}, - }, -) - -S3_LOCATION = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#S3Location"), - members={ - "uri": { - "target": S3_URI, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - "bucketOwner": {"target": ACCOUNT_ID}, - }, -) - -AUDIO_SOURCE = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#AudioSource"), - shape_type=ShapeType.UNION, - traits=[Trait.new(id=ShapeID("smithy.api#sensitive"))], - members={"bytes": {"target": BLOB}, "s3Location": {"target": S3_LOCATION}}, -) - -AUDIO_BLOCK = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#AudioBlock"), - members={ - "format": { - "target": AUDIO_FORMAT, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - "source": { - "target": AUDIO_SOURCE, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - "error": {"target": ERROR_BLOCK}, }, + CONVERSE_STREAM_INPUT, + CONVERSE_STREAM_OPERATION_OUTPUT, + ( + ACCESS_DENIED_EXCEPTION, + INTERNAL_SERVER_EXCEPTION, + MODEL_ERROR_EXCEPTION, + MODEL_NOT_READY_EXCEPTION, + MODEL_TIMEOUT_EXCEPTION, + RESOURCE_NOT_FOUND_EXCEPTION, + SERVICE_UNAVAILABLE_EXCEPTION, + THROTTLING_EXCEPTION, + VALIDATION_EXCEPTION, + ), ) -CACHE_TTL = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#CacheTTL"), - shape_type=ShapeType.ENUM, - members={"FIVE_MINUTES": {"target": UNIT}, "ONE_HOUR": {"target": UNIT}}, +MIME_TYPE: StaticSchema = (3, n0, _MTi, 0) + +BODY: StaticSchema = (1, n0, _B, 4) + +INVOKE_MODEL_IDENTIFIER: StaticSchema = (3, n0, _IMIn, 0) + +REQUEST_METADATA_JSON: StaticSchema = (3, n0, _RMJ, 4) + +TRACE: StaticSchema = ( + 14, + n0, + _Tr, + 0, + (_ENABLED, _DISABLED, _EF), + ((-1, 0), (-1, 0), (-1, 0)), +) + +INVOKE_MODEL_INPUT: StaticSchema = ( + 18, + n0, + _IMInv, + {_sSI: _cIMR}, + (_bo, _cT, _ac, _mI, _trac, _gI, _gV, _pCL, _sTe, _rM), + ( + (BODY, 16), + (MIME_TYPE, {_sH: _CT_}), + (MIME_TYPE, {_sH: _A}), + (INVOKE_MODEL_IDENTIFIER, 9), + (TRACE, {_sH: _XABT}), + (GUARDRAIL_IDENTIFIER, {_sH: _XABG}), + (GUARDRAIL_VERSION, {_sH: _XABG_}), + (PERFORMANCE_CONFIG_LATENCY, {_smith: _stan, _sH: _XABPL}), + (SERVICE_TIER_TYPE, {_sH: _XABST}), + (REQUEST_METADATA_JSON, {_sH: _XABRM}), + ), ) -CACHE_POINT_TYPE = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#CachePointType"), - shape_type=ShapeType.ENUM, - members={"DEFAULT": {"target": UNIT}}, +INVOKE_MODEL_OUTPUT: StaticSchema = ( + 18, + n0, + _IMO, + {_sSI: _cIMRo}, + (_bo, _cT, _pCL, _sTe), + ( + (BODY, 17), + (MIME_TYPE, {_sH: _CT_, _sm: None}), + (PERFORMANCE_CONFIG_LATENCY, {_sH: _XABPL}), + (SERVICE_TIER_TYPE, {_sH: _XABST}), + ), ) -CACHE_POINT_BLOCK = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#CachePointBlock"), - members={ - "type": { - "target": CACHE_POINT_TYPE, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - "ttl": {"target": CACHE_TTL}, +INVOKE_MODEL: StaticOperationSchema = ( + 23, + n0, + _IM, + { + _smit: MappingProxyType( + {"code": 200, "method": "POST", "uri": "/model/{modelId}/invoke"} + ) }, + INVOKE_MODEL_INPUT, + INVOKE_MODEL_OUTPUT, + ( + ACCESS_DENIED_EXCEPTION, + INTERNAL_SERVER_EXCEPTION, + MODEL_ERROR_EXCEPTION, + MODEL_NOT_READY_EXCEPTION, + MODEL_TIMEOUT_EXCEPTION, + RESOURCE_NOT_FOUND_EXCEPTION, + SERVICE_QUOTA_EXCEEDED_EXCEPTION, + SERVICE_UNAVAILABLE_EXCEPTION, + THROTTLING_EXCEPTION, + VALIDATION_EXCEPTION, + ), ) -DOCUMENT_CHAR_LOCATION = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#DocumentCharLocation"), - members={ - "documentIndex": {"target": INTEGER}, - "start": {"target": INTEGER}, - "end": {"target": INTEGER}, - }, +PART_BODY: StaticSchema = (1, n0, _PB, 4) + +BIDIRECTIONAL_INPUT_PAYLOAD_PART: StaticSchema = ( + 18, + n0, + _BIPP, + 4, + (_b,), + ((PART_BODY, 0),), +) + +INVOKE_MODEL_WITH_BIDIRECTIONAL_STREAM_INPUT: StaticSchema = ( + 19, + n0, + _IMWBSI, + {_smithy: None}, + (_chu,), + ((BIDIRECTIONAL_INPUT_PAYLOAD_PART, 0),), +) + +INVOKE_MODEL_WITH_BIDIRECTIONAL_STREAM_OPERATION_INPUT: StaticSchema = ( + 18, + n0, + _IMWBSOI, + {_sSI: _cIMWBSR}, + (_mI, _bo), + ((INVOKE_MODEL_IDENTIFIER, 9), (INVOKE_MODEL_WITH_BIDIRECTIONAL_STREAM_INPUT, 17)), +) + +BIDIRECTIONAL_OUTPUT_PAYLOAD_PART: StaticSchema = ( + 18, + n0, + _BOPP, + 4, + (_b,), + ((PART_BODY, 0),), +) + +INVOKE_MODEL_WITH_BIDIRECTIONAL_STREAM_OUTPUT: StaticSchema = ( + 19, + n0, + _IMWBSO, + {_smithy: None}, + (_chu, _iSE, _mSEE, _vE, _tE, _mTE, _sUE), + ( + (BIDIRECTIONAL_OUTPUT_PAYLOAD_PART, 0), + (INTERNAL_SERVER_EXCEPTION, 0), + (MODEL_STREAM_ERROR_EXCEPTION, 0), + (VALIDATION_EXCEPTION, 0), + (THROTTLING_EXCEPTION, 0), + (MODEL_TIMEOUT_EXCEPTION, 0), + (SERVICE_UNAVAILABLE_EXCEPTION, 0), + ), ) -DOCUMENT_CHUNK_LOCATION = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#DocumentChunkLocation"), - members={ - "documentIndex": {"target": INTEGER}, - "start": {"target": INTEGER}, - "end": {"target": INTEGER}, +INVOKE_MODEL_WITH_BIDIRECTIONAL_STREAM_OPERATION_OUTPUT: StaticSchema = ( + 18, + n0, + _IMWBSOO, + {_sSI: _cIMWBSRo}, + (_bo,), + ((INVOKE_MODEL_WITH_BIDIRECTIONAL_STREAM_OUTPUT, 17),), +) + +INVOKE_MODEL_WITH_BIDIRECTIONAL_STREAM: StaticOperationSchema = ( + 23, + n0, + _IMWBS, + { + _smit: MappingProxyType( + { + "code": 200, + "method": "POST", + "uri": "/model/{modelId}/invoke-with-bidirectional-stream", + } + ) }, + INVOKE_MODEL_WITH_BIDIRECTIONAL_STREAM_OPERATION_INPUT, + INVOKE_MODEL_WITH_BIDIRECTIONAL_STREAM_OPERATION_OUTPUT, + ( + ACCESS_DENIED_EXCEPTION, + INTERNAL_SERVER_EXCEPTION, + MODEL_ERROR_EXCEPTION, + MODEL_NOT_READY_EXCEPTION, + MODEL_STREAM_ERROR_EXCEPTION, + MODEL_TIMEOUT_EXCEPTION, + RESOURCE_NOT_FOUND_EXCEPTION, + SERVICE_QUOTA_EXCEEDED_EXCEPTION, + SERVICE_UNAVAILABLE_EXCEPTION, + THROTTLING_EXCEPTION, + VALIDATION_EXCEPTION, + ), ) -DOCUMENT_PAGE_LOCATION = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#DocumentPageLocation"), - members={ - "documentIndex": {"target": INTEGER}, - "start": {"target": INTEGER}, - "end": {"target": INTEGER}, - }, +INVOKE_MODEL_WITH_RESPONSE_STREAM_INPUT: StaticSchema = ( + 18, + n0, + _IMWRSI, + {_sSI: _cIMWRSR}, + (_bo, _cT, _ac, _mI, _trac, _gI, _gV, _pCL, _sTe, _rM), + ( + (BODY, 16), + (MIME_TYPE, {_sH: _CT_}), + (MIME_TYPE, {_sH: _XABA}), + (INVOKE_MODEL_IDENTIFIER, 9), + (TRACE, {_sH: _XABT}), + (GUARDRAIL_IDENTIFIER, {_sH: _XABG}), + (GUARDRAIL_VERSION, {_sH: _XABG_}), + (PERFORMANCE_CONFIG_LATENCY, {_smith: _stan, _sH: _XABPL}), + (SERVICE_TIER_TYPE, {_sH: _XABST}), + (REQUEST_METADATA_JSON, {_sH: _XABRM}), + ), ) -SEARCH_RESULT_LOCATION = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#SearchResultLocation"), - members={ - "searchResultIndex": {"target": INTEGER}, - "start": {"target": INTEGER}, - "end": {"target": INTEGER}, - }, +PAYLOAD_PART: StaticSchema = (18, n0, _PP, 4, (_b,), ((PART_BODY, 0),)) + +RESPONSE_STREAM: StaticSchema = ( + 19, + n0, + _RS, + {_smithy: None}, + (_chu, _iSE, _mSEE, _vE, _tE, _mTE, _sUE), + ( + (PAYLOAD_PART, 0), + (INTERNAL_SERVER_EXCEPTION, 0), + (MODEL_STREAM_ERROR_EXCEPTION, 0), + (VALIDATION_EXCEPTION, 0), + (THROTTLING_EXCEPTION, 0), + (MODEL_TIMEOUT_EXCEPTION, 0), + (SERVICE_UNAVAILABLE_EXCEPTION, 0), + ), ) -WEB_LOCATION = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#WebLocation"), - members={"url": {"target": STRING}, "domain": {"target": STRING}}, +INVOKE_MODEL_WITH_RESPONSE_STREAM_OUTPUT: StaticSchema = ( + 18, + n0, + _IMWRSO, + {_sSI: _cIMWRSRo}, + (_bo, _cT, _pCL, _sTe), + ( + (RESPONSE_STREAM, 17), + (MIME_TYPE, {_sH: _XABCT, _sm: None}), + (PERFORMANCE_CONFIG_LATENCY, {_sH: _XABPL}), + (SERVICE_TIER_TYPE, {_sH: _XABST}), + ), ) -CITATION_LOCATION = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#CitationLocation"), - shape_type=ShapeType.UNION, - members={ - "web": {"target": WEB_LOCATION}, - "documentChar": {"target": DOCUMENT_CHAR_LOCATION}, - "documentPage": {"target": DOCUMENT_PAGE_LOCATION}, - "documentChunk": {"target": DOCUMENT_CHUNK_LOCATION}, - "searchResultLocation": {"target": SEARCH_RESULT_LOCATION}, +INVOKE_MODEL_WITH_RESPONSE_STREAM: StaticOperationSchema = ( + 23, + n0, + _IMWRS, + { + _smit: MappingProxyType( + { + "code": 200, + "method": "POST", + "uri": "/model/{modelId}/invoke-with-response-stream", + } + ) }, + INVOKE_MODEL_WITH_RESPONSE_STREAM_INPUT, + INVOKE_MODEL_WITH_RESPONSE_STREAM_OUTPUT, + ( + ACCESS_DENIED_EXCEPTION, + INTERNAL_SERVER_EXCEPTION, + MODEL_ERROR_EXCEPTION, + MODEL_NOT_READY_EXCEPTION, + MODEL_STREAM_ERROR_EXCEPTION, + MODEL_TIMEOUT_EXCEPTION, + RESOURCE_NOT_FOUND_EXCEPTION, + SERVICE_QUOTA_EXCEEDED_EXCEPTION, + SERVICE_UNAVAILABLE_EXCEPTION, + THROTTLING_EXCEPTION, + VALIDATION_EXCEPTION, + ), ) -CITATION_SOURCE_CONTENT = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#CitationSourceContent"), - shape_type=ShapeType.UNION, - members={"text": {"target": STRING}}, +CONVERSE_TOKENS_REQUEST: StaticSchema = ( + 18, + n0, + _CTR, + 0, + (_mes, _sy, _tCoo, _aMRF), + ((MESSAGES, 0), (SYSTEM_CONTENT_BLOCKS, 0), (TOOL_CONFIGURATION, 0), (13, 0)), ) -CITATION_SOURCE_CONTENT_LIST = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#CitationSourceContentList"), - shape_type=ShapeType.LIST, - members={"member": {"target": CITATION_SOURCE_CONTENT}}, -) +INVOKE_MODEL_TOKENS_REQUEST: StaticSchema = (18, n0, _IMTR, 0, (_bo,), ((BODY, 1),)) -CITATION = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#Citation"), - members={ - "title": {"target": STRING}, - "source": {"target": STRING}, - "sourceContent": {"target": CITATION_SOURCE_CONTENT_LIST}, - "location": {"target": CITATION_LOCATION}, - }, +COUNT_TOKENS_INPUT: StaticSchema = ( + 19, + n0, + _CTI, + 0, + (_iMn, _conv), + ((INVOKE_MODEL_TOKENS_REQUEST, 0), (CONVERSE_TOKENS_REQUEST, 0)), ) -CITATIONS = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#Citations"), - shape_type=ShapeType.LIST, - members={"member": {"target": CITATION}}, -) +FOUNDATION_MODEL_VERSION_IDENTIFIER: StaticSchema = (3, n0, _FMVI, 0) -CITATION_GENERATED_CONTENT = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#CitationGeneratedContent"), - shape_type=ShapeType.UNION, - members={"text": {"target": STRING}}, +COUNT_TOKENS_OPERATION_INPUT: StaticSchema = ( + 18, + n0, + _CTOI, + {_sSI: _cCTR}, + (_mI, _inp), + ((FOUNDATION_MODEL_VERSION_IDENTIFIER, 9), (COUNT_TOKENS_INPUT, 1)), ) -CITATION_GENERATED_CONTENT_LIST = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#CitationGeneratedContentList"), - shape_type=ShapeType.LIST, - members={"member": {"target": CITATION_GENERATED_CONTENT}}, -) +COUNT_TOKENS_OUTPUT: StaticSchema = (18, n0, _CTO, {_sSI: _cCTRo}, (_iT,), ((7, 1),)) -CITATIONS_CONTENT_BLOCK = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#CitationsContentBlock"), - members={ - "content": {"target": CITATION_GENERATED_CONTENT_LIST}, - "citations": {"target": CITATIONS}, +COUNT_TOKENS: StaticOperationSchema = ( + 23, + n0, + _CTo, + { + _smit: MappingProxyType( + {"code": 200, "method": "POST", "uri": "/model/{modelId}/count-tokens"} + ) }, + COUNT_TOKENS_OPERATION_INPUT, + COUNT_TOKENS_OUTPUT, + ( + ACCESS_DENIED_EXCEPTION, + INTERNAL_SERVER_EXCEPTION, + RESOURCE_NOT_FOUND_EXCEPTION, + SERVICE_UNAVAILABLE_EXCEPTION, + THROTTLING_EXCEPTION, + VALIDATION_EXCEPTION, + ), ) -CITATIONS_CONFIG = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#CitationsConfig"), - members={ - "enabled": { - "target": BOOLEAN, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - } - }, -) - -DOCUMENT_FORMAT = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#DocumentFormat"), - shape_type=ShapeType.ENUM, - members={ - "PDF": {"target": UNIT}, - "CSV": {"target": UNIT}, - "DOC": {"target": UNIT}, - "DOCX": {"target": UNIT}, - "XLS": {"target": UNIT}, - "XLSX": {"target": UNIT}, - "HTML": {"target": UNIT}, - "TXT": {"target": UNIT}, - "MD": {"target": UNIT}, - }, -) - -DOCUMENT_CONTENT_BLOCK = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#DocumentContentBlock"), - shape_type=ShapeType.UNION, - members={"text": {"target": STRING}}, -) - -DOCUMENT_CONTENT_BLOCKS = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#DocumentContentBlocks"), - shape_type=ShapeType.LIST, - members={"member": {"target": DOCUMENT_CONTENT_BLOCK}}, -) - -DOCUMENT_SOURCE = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#DocumentSource"), - shape_type=ShapeType.UNION, - members={ - "bytes": {"target": BLOB}, - "s3Location": {"target": S3_LOCATION}, - "text": {"target": STRING}, - "content": {"target": DOCUMENT_CONTENT_BLOCKS}, - }, -) - -DOCUMENT_BLOCK = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#DocumentBlock"), - members={ - "format": { - "target": DOCUMENT_FORMAT, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value="txt")], - }, - "name": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - "source": { - "target": DOCUMENT_SOURCE, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - "context": {"target": STRING}, - "citations": {"target": CITATIONS_CONFIG}, - }, -) - -GUARDRAIL_CONVERSE_IMAGE_FORMAT = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#GuardrailConverseImageFormat"), - shape_type=ShapeType.ENUM, - members={"PNG": {"target": UNIT}, "JPEG": {"target": UNIT}}, -) - -GUARDRAIL_CONVERSE_IMAGE_SOURCE = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#GuardrailConverseImageSource"), - shape_type=ShapeType.UNION, - traits=[Trait.new(id=ShapeID("smithy.api#sensitive"))], - members={"bytes": {"target": BLOB}}, -) - -GUARDRAIL_CONVERSE_IMAGE_BLOCK = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#GuardrailConverseImageBlock"), - traits=[Trait.new(id=ShapeID("smithy.api#sensitive"))], - members={ - "format": { - "target": GUARDRAIL_CONVERSE_IMAGE_FORMAT, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - "source": { - "target": GUARDRAIL_CONVERSE_IMAGE_SOURCE, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - }, -) - -GUARDRAIL_CONVERSE_CONTENT_QUALIFIER = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#GuardrailConverseContentQualifier"), - shape_type=ShapeType.ENUM, - members={ - "GROUNDING_SOURCE": {"target": UNIT}, - "QUERY": {"target": UNIT}, - "GUARD_CONTENT": {"target": UNIT}, - }, -) - -GUARDRAIL_CONVERSE_CONTENT_QUALIFIER_LIST = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#GuardrailConverseContentQualifierList"), - shape_type=ShapeType.LIST, - members={"member": {"target": GUARDRAIL_CONVERSE_CONTENT_QUALIFIER}}, -) - -GUARDRAIL_CONVERSE_TEXT_BLOCK = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#GuardrailConverseTextBlock"), - members={ - "text": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - "qualifiers": {"target": GUARDRAIL_CONVERSE_CONTENT_QUALIFIER_LIST}, - }, -) - -GUARDRAIL_CONVERSE_CONTENT_BLOCK = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#GuardrailConverseContentBlock"), - shape_type=ShapeType.UNION, - members={ - "text": {"target": GUARDRAIL_CONVERSE_TEXT_BLOCK}, - "image": {"target": GUARDRAIL_CONVERSE_IMAGE_BLOCK}, - }, -) - -IMAGE_FORMAT = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#ImageFormat"), - shape_type=ShapeType.ENUM, - members={ - "PNG": {"target": UNIT}, - "JPEG": {"target": UNIT}, - "GIF": {"target": UNIT}, - "WEBP": {"target": UNIT}, - }, -) - -IMAGE_SOURCE = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#ImageSource"), - shape_type=ShapeType.UNION, - traits=[Trait.new(id=ShapeID("smithy.api#sensitive"))], - members={"bytes": {"target": BLOB}, "s3Location": {"target": S3_LOCATION}}, -) - -IMAGE_BLOCK = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#ImageBlock"), - members={ - "format": { - "target": IMAGE_FORMAT, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - "source": { - "target": IMAGE_SOURCE, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - "error": {"target": ERROR_BLOCK}, - }, -) - -REASONING_TEXT_BLOCK = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#ReasoningTextBlock"), - traits=[Trait.new(id=ShapeID("smithy.api#sensitive"))], - members={ - "text": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - "signature": {"target": STRING}, - }, -) - -REASONING_CONTENT_BLOCK = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#ReasoningContentBlock"), - shape_type=ShapeType.UNION, - traits=[Trait.new(id=ShapeID("smithy.api#sensitive"))], - members={ - "reasoningText": {"target": REASONING_TEXT_BLOCK}, - "redactedContent": {"target": BLOB}, - }, -) - -SEARCH_RESULT_CONTENT_BLOCK = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#SearchResultContentBlock"), - members={ - "text": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - } - }, -) - -SEARCH_RESULT_CONTENT_BLOCKS = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#SearchResultContentBlocks"), - shape_type=ShapeType.LIST, - members={"member": {"target": SEARCH_RESULT_CONTENT_BLOCK}}, -) - -SEARCH_RESULT_BLOCK = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#SearchResultBlock"), - members={ - "source": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - "title": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - "content": { - "target": SEARCH_RESULT_CONTENT_BLOCKS, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - "citations": {"target": CITATIONS_CONFIG}, - }, -) - -TOOL_REFERENCE = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#ToolReference"), - members={ - "type": {"target": STRING}, - "name": {"target": STRING}, - "serverName": {"target": STRING}, - }, -) - -TOOL_ADDITION_BLOCK = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#ToolAdditionBlock"), - members={ - "tool": { - "target": TOOL_REFERENCE, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - } - }, -) - -TOOL_REMOVAL_BLOCK = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#ToolRemovalBlock"), - members={ - "tool": { - "target": TOOL_REFERENCE, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - } - }, -) - -VIDEO_FORMAT = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#VideoFormat"), - shape_type=ShapeType.ENUM, - members={ - "MKV": {"target": UNIT}, - "MOV": {"target": UNIT}, - "MP4": {"target": UNIT}, - "WEBM": {"target": UNIT}, - "FLV": {"target": UNIT}, - "MPEG": {"target": UNIT}, - "MPG": {"target": UNIT}, - "WMV": {"target": UNIT}, - "THREE_GP": {"target": UNIT}, - }, -) - -VIDEO_SOURCE = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#VideoSource"), - shape_type=ShapeType.UNION, - members={"bytes": {"target": BLOB}, "s3Location": {"target": S3_LOCATION}}, -) - -VIDEO_BLOCK = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#VideoBlock"), - members={ - "format": { - "target": VIDEO_FORMAT, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - "source": { - "target": VIDEO_SOURCE, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - }, -) - -TOOL_RESULT_CONTENT_BLOCK = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#ToolResultContentBlock"), - shape_type=ShapeType.UNION, - members={ - "json": {"target": DOCUMENT}, - "text": {"target": STRING}, - "image": {"target": IMAGE_BLOCK}, - "document": {"target": DOCUMENT_BLOCK}, - "video": {"target": VIDEO_BLOCK}, - "searchResult": {"target": SEARCH_RESULT_BLOCK}, - }, -) - -TOOL_RESULT_CONTENT_BLOCKS = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#ToolResultContentBlocks"), - shape_type=ShapeType.LIST, - members={"member": {"target": TOOL_RESULT_CONTENT_BLOCK}}, -) - -TOOL_RESULT_STATUS = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#ToolResultStatus"), - shape_type=ShapeType.ENUM, - members={"SUCCESS": {"target": UNIT}, "ERROR": {"target": UNIT}}, -) - -TOOL_USE_ID = Schema( - id=ShapeID("com.amazonaws.bedrockruntime#ToolUseId"), shape_type=ShapeType.STRING -) - -TOOL_RESULT_BLOCK = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#ToolResultBlock"), - members={ - "toolUseId": { - "target": TOOL_USE_ID, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - "content": { - "target": TOOL_RESULT_CONTENT_BLOCKS, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - "status": {"target": TOOL_RESULT_STATUS}, - "type": {"target": STRING}, - }, -) - -TOOL_NAME = Schema( - id=ShapeID("com.amazonaws.bedrockruntime#ToolName"), shape_type=ShapeType.STRING -) - -TOOL_USE_TYPE = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#ToolUseType"), - shape_type=ShapeType.ENUM, - members={"SERVER_TOOL_USE": {"target": UNIT}}, -) - -TOOL_USE_BLOCK = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#ToolUseBlock"), - members={ - "toolUseId": { - "target": TOOL_USE_ID, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - "name": { - "target": TOOL_NAME, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - "input": { - "target": DOCUMENT, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - "type": {"target": TOOL_USE_TYPE}, - }, -) - -CONTENT_BLOCK = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#ContentBlock"), - shape_type=ShapeType.UNION, - members={ - "text": {"target": STRING}, - "image": {"target": IMAGE_BLOCK}, - "document": {"target": DOCUMENT_BLOCK}, - "video": {"target": VIDEO_BLOCK}, - "audio": {"target": AUDIO_BLOCK}, - "toolUse": {"target": TOOL_USE_BLOCK}, - "toolResult": {"target": TOOL_RESULT_BLOCK}, - "guardContent": {"target": GUARDRAIL_CONVERSE_CONTENT_BLOCK}, - "cachePoint": {"target": CACHE_POINT_BLOCK}, - "reasoningContent": {"target": REASONING_CONTENT_BLOCK}, - "citationsContent": {"target": CITATIONS_CONTENT_BLOCK}, - "searchResult": {"target": SEARCH_RESULT_BLOCK}, - "toolAddition": {"target": TOOL_ADDITION_BLOCK}, - "toolRemoval": {"target": TOOL_REMOVAL_BLOCK}, - }, -) - -CONTENT_BLOCKS = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#ContentBlocks"), - shape_type=ShapeType.LIST, - members={"member": {"target": CONTENT_BLOCK}}, -) - -CONVERSATION_ROLE = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#ConversationRole"), - shape_type=ShapeType.ENUM, - members={ - "USER": {"target": UNIT}, - "ASSISTANT": {"target": UNIT}, - "SYSTEM": {"target": UNIT}, - }, -) - -MESSAGE = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#Message"), - members={ - "role": { - "target": CONVERSATION_ROLE, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - "content": { - "target": CONTENT_BLOCKS, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - }, -) - -MESSAGES = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#Messages"), - shape_type=ShapeType.LIST, - members={"member": {"target": MESSAGE}}, -) - -CONVERSATIONAL_MODEL_ID = Schema( - id=ShapeID("com.amazonaws.bedrockruntime#ConversationalModelId"), - shape_type=ShapeType.STRING, -) - -JSON_SCHEMA_DEFINITION = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#JsonSchemaDefinition"), - members={ - "schema": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - "name": {"target": STRING}, - "description": {"target": STRING}, - }, -) - -OUTPUT_FORMAT_STRUCTURE = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#OutputFormatStructure"), - shape_type=ShapeType.UNION, - traits=[Trait.new(id=ShapeID("smithy.api#sensitive"))], - members={"jsonSchema": {"target": JSON_SCHEMA_DEFINITION}}, -) - -OUTPUT_FORMAT_TYPE = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#OutputFormatType"), - shape_type=ShapeType.ENUM, - members={"JSON_SCHEMA": {"target": UNIT}}, -) - -OUTPUT_FORMAT = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#OutputFormat"), - members={ - "type": { - "target": OUTPUT_FORMAT_TYPE, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - "structure": { - "target": OUTPUT_FORMAT_STRUCTURE, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - }, -) - -OUTPUT_CONFIG = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#OutputConfig"), - members={"textFormat": {"target": OUTPUT_FORMAT}, "effort": {"target": STRING}}, -) - -PERFORMANCE_CONFIG_LATENCY = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#PerformanceConfigLatency"), - shape_type=ShapeType.ENUM, - members={"STANDARD": {"target": UNIT}, "OPTIMIZED": {"target": UNIT}}, -) - -PERFORMANCE_CONFIGURATION = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#PerformanceConfiguration"), - members={ - "latency": { - "target": PERFORMANCE_CONFIG_LATENCY, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value="standard")], - } - }, -) - -PROMPT_VARIABLE_VALUES = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#PromptVariableValues"), - shape_type=ShapeType.UNION, - members={"text": {"target": STRING}}, -) - -PROMPT_VARIABLE_MAP = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#PromptVariableMap"), - shape_type=ShapeType.MAP, - traits=[Trait.new(id=ShapeID("smithy.api#sensitive"))], - members={"key": {"target": STRING}, "value": {"target": PROMPT_VARIABLE_VALUES}}, -) - -REQUEST_METADATA = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#RequestMetadata"), - shape_type=ShapeType.MAP, - traits=[Trait.new(id=ShapeID("smithy.api#sensitive"))], - members={"key": {"target": STRING}, "value": {"target": STRING}}, -) - -SERVICE_TIER_TYPE = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#ServiceTierType"), - shape_type=ShapeType.ENUM, - members={ - "PRIORITY": {"target": UNIT}, - "DEFAULT": {"target": UNIT}, - "FLEX": {"target": UNIT}, - "RESERVED": {"target": UNIT}, - }, -) - -SERVICE_TIER = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#ServiceTier"), - members={ - "type": { - "target": SERVICE_TIER_TYPE, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - } - }, -) - -SYSTEM_CONTENT_BLOCK = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#SystemContentBlock"), - shape_type=ShapeType.UNION, - members={ - "text": {"target": NON_EMPTY_STRING}, - "guardContent": {"target": GUARDRAIL_CONVERSE_CONTENT_BLOCK}, - "cachePoint": {"target": CACHE_POINT_BLOCK}, - }, -) - -SYSTEM_CONTENT_BLOCKS = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#SystemContentBlocks"), - shape_type=ShapeType.LIST, - members={"member": {"target": SYSTEM_CONTENT_BLOCK}}, -) - -ANY_TOOL_CHOICE = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#AnyToolChoice") -) - -AUTO_TOOL_CHOICE = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#AutoToolChoice") -) - -SPECIFIC_TOOL_CHOICE = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#SpecificToolChoice"), - members={ - "name": { - "target": TOOL_NAME, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - } - }, -) - -TOOL_CHOICE = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#ToolChoice"), - shape_type=ShapeType.UNION, - members={ - "auto": {"target": AUTO_TOOL_CHOICE}, - "any": {"target": ANY_TOOL_CHOICE}, - "tool": {"target": SPECIFIC_TOOL_CHOICE}, - }, -) - -SYSTEM_TOOL = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#SystemTool"), - members={ - "name": { - "target": TOOL_NAME, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - } - }, -) - -TOOL_INPUT_SCHEMA = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#ToolInputSchema"), - shape_type=ShapeType.UNION, - members={"json": {"target": DOCUMENT}}, -) - -TOOL_SPECIFICATION = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#ToolSpecification"), - members={ - "name": { - "target": TOOL_NAME, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - "description": {"target": NON_EMPTY_STRING}, - "inputSchema": { - "target": TOOL_INPUT_SCHEMA, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - "strict": {"target": BOOLEAN}, - }, -) - -TOOL = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#Tool"), - shape_type=ShapeType.UNION, - members={ - "toolSpec": {"target": TOOL_SPECIFICATION}, - "systemTool": {"target": SYSTEM_TOOL}, - "cachePoint": {"target": CACHE_POINT_BLOCK}, - }, -) - -TOOLS = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#Tools"), - shape_type=ShapeType.LIST, - members={"member": {"target": TOOL}}, -) - -TOOL_CONFIGURATION = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#ToolConfiguration"), - members={ - "tools": { - "target": TOOLS, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - "toolChoice": {"target": TOOL_CHOICE}, - }, -) - -CONVERSE_INPUT = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#ConverseInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="com.amazonaws.bedrockruntime#ConverseRequest", - ) - ], - members={ - "modelId": { - "target": CONVERSATIONAL_MODEL_ID, - "traits": [ - Trait.new(id=ShapeID("smithy.api#required")), - Trait.new(id=ShapeID("smithy.api#httpLabel")), - ], - }, - "messages": {"target": MESSAGES}, - "system": {"target": SYSTEM_CONTENT_BLOCKS}, - "inferenceConfig": {"target": INFERENCE_CONFIGURATION}, - "toolConfig": {"target": TOOL_CONFIGURATION}, - "guardrailConfig": {"target": GUARDRAIL_CONFIGURATION}, - "additionalModelRequestFields": {"target": DOCUMENT}, - "promptVariables": {"target": PROMPT_VARIABLE_MAP}, - "additionalModelResponseFieldPaths": { - "target": ADDITIONAL_MODEL_RESPONSE_FIELD_PATHS - }, - "requestMetadata": {"target": REQUEST_METADATA}, - "performanceConfig": {"target": PERFORMANCE_CONFIGURATION}, - "serviceTier": {"target": SERVICE_TIER}, - "outputConfig": {"target": OUTPUT_CONFIG}, - }, -) - -CONVERSE_METRICS = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#ConverseMetrics"), - members={ - "latencyMs": { - "target": LONG, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - } - }, -) - -CONVERSE_OUTPUT = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#ConverseOutput"), - shape_type=ShapeType.UNION, - members={"message": {"target": MESSAGE}}, -) - -STOP_REASON = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#StopReason"), - shape_type=ShapeType.ENUM, - members={ - "END_TURN": {"target": UNIT}, - "TOOL_USE": {"target": UNIT}, - "MAX_TOKENS": {"target": UNIT}, - "STOP_SEQUENCE": {"target": UNIT}, - "GUARDRAIL_INTERVENED": {"target": UNIT}, - "CONTENT_FILTERED": {"target": UNIT}, - "MALFORMED_MODEL_OUTPUT": {"target": UNIT}, - "MALFORMED_TOOL_USE": {"target": UNIT}, - "MODEL_CONTEXT_WINDOW_EXCEEDED": {"target": UNIT}, - }, -) - -GUARDRAIL_ASSESSMENT_MAP = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#GuardrailAssessmentMap"), - shape_type=ShapeType.MAP, - members={"key": {"target": STRING}, "value": {"target": GUARDRAIL_ASSESSMENT}}, -) - -MODEL_OUTPUTS = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#ModelOutputs"), - shape_type=ShapeType.LIST, - members={"member": {"target": GUARDRAIL_OUTPUT_TEXT}}, -) - -GUARDRAIL_ASSESSMENT_LIST_MAP = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#GuardrailAssessmentListMap"), - shape_type=ShapeType.MAP, - members={"key": {"target": STRING}, "value": {"target": GUARDRAIL_ASSESSMENT_LIST}}, -) - -GUARDRAIL_TRACE_ASSESSMENT = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#GuardrailTraceAssessment"), - members={ - "modelOutput": {"target": MODEL_OUTPUTS}, - "inputAssessment": {"target": GUARDRAIL_ASSESSMENT_MAP}, - "outputAssessments": {"target": GUARDRAIL_ASSESSMENT_LIST_MAP}, - "actionReason": {"target": STRING}, - }, -) - -INVOKED_MODEL_ID = Schema( - id=ShapeID("com.amazonaws.bedrockruntime#InvokedModelId"), - shape_type=ShapeType.STRING, -) - -PROMPT_ROUTER_TRACE = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#PromptRouterTrace"), - members={"invokedModelId": {"target": INVOKED_MODEL_ID}}, -) - -CONVERSE_TRACE = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#ConverseTrace"), - members={ - "guardrail": {"target": GUARDRAIL_TRACE_ASSESSMENT}, - "promptRouter": {"target": PROMPT_ROUTER_TRACE}, - }, -) - -CACHE_DETAIL = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#CacheDetail"), - members={ - "ttl": { - "target": CACHE_TTL, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - "inputTokens": { - "target": INTEGER, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - }, -) - -CACHE_DETAILS_LIST = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#CacheDetailsList"), - shape_type=ShapeType.LIST, - members={"member": {"target": CACHE_DETAIL}}, -) - -TOKEN_USAGE = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#TokenUsage"), - members={ - "inputTokens": { - "target": INTEGER, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - "outputTokens": { - "target": INTEGER, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - "totalTokens": { - "target": INTEGER, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - "cacheReadInputTokens": {"target": INTEGER}, - "cacheWriteInputTokens": {"target": INTEGER}, - "cacheDetails": {"target": CACHE_DETAILS_LIST}, - }, -) - -CONVERSE_OPERATION_OUTPUT = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#ConverseOperationOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="com.amazonaws.bedrockruntime#ConverseResponse", - ) - ], - members={ - "output": { - "target": CONVERSE_OUTPUT, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - "stopReason": { - "target": STOP_REASON, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - "usage": { - "target": TOKEN_USAGE, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - "metrics": { - "target": CONVERSE_METRICS, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - "additionalModelResponseFields": {"target": DOCUMENT}, - "trace": {"target": CONVERSE_TRACE}, - "performanceConfig": {"target": PERFORMANCE_CONFIGURATION}, - "serviceTier": {"target": SERVICE_TIER}, - }, -) - -STATUS_CODE = Schema( - id=ShapeID("com.amazonaws.bedrockruntime#StatusCode"), shape_type=ShapeType.INTEGER -) - -MODEL_ERROR_EXCEPTION = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#ModelErrorException"), - traits=[ - Trait.new(id=ShapeID("smithy.api#error"), value="client"), - Trait.new(id=ShapeID("smithy.api#httpError"), value=424), - ], - members={ - "message": {"target": NON_BLANK_STRING}, - "originalStatusCode": {"target": STATUS_CODE}, - "resourceName": {"target": NON_BLANK_STRING}, - }, -) - -MODEL_NOT_READY_EXCEPTION = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#ModelNotReadyException"), - traits=[ - Trait.new(id=ShapeID("smithy.api#error"), value="client"), - Trait.new(id=ShapeID("smithy.api#httpError"), value=429), - ], - members={"message": {"target": NON_BLANK_STRING}}, -) - -MODEL_TIMEOUT_EXCEPTION = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#ModelTimeoutException"), - traits=[ - Trait.new(id=ShapeID("smithy.api#error"), value="client"), - Trait.new(id=ShapeID("smithy.api#httpError"), value=408), - ], - members={"message": {"target": NON_BLANK_STRING}}, -) - -CONVERSE = Schema( - id=ShapeID("com.amazonaws.bedrockruntime#Converse"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType( - {"code": 200, "method": "POST", "uri": "/model/{modelId}/converse"} - ), - ) - ], -) - -GUARDRAIL_STREAM_PROCESSING_MODE = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#GuardrailStreamProcessingMode"), - shape_type=ShapeType.ENUM, - members={"SYNC": {"target": UNIT}, "ASYNC": {"target": UNIT}}, -) - -GUARDRAIL_STREAM_CONFIGURATION = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#GuardrailStreamConfiguration"), - members={ - "guardrailIdentifier": { - "target": GUARDRAIL_IDENTIFIER, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value="")], - }, - "guardrailVersion": { - "target": GUARDRAIL_VERSION, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value="")], - }, - "trace": { - "target": GUARDRAIL_TRACE, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value="disabled")], - }, - "streamProcessingMode": { - "target": GUARDRAIL_STREAM_PROCESSING_MODE, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value="sync")], - }, - }, -) - -CONVERSE_STREAM_INPUT = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#ConverseStreamInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="com.amazonaws.bedrockruntime#ConverseStreamRequest", - ) - ], - members={ - "modelId": { - "target": CONVERSATIONAL_MODEL_ID, - "traits": [ - Trait.new(id=ShapeID("smithy.api#required")), - Trait.new(id=ShapeID("smithy.api#httpLabel")), - ], - }, - "messages": {"target": MESSAGES}, - "system": {"target": SYSTEM_CONTENT_BLOCKS}, - "inferenceConfig": {"target": INFERENCE_CONFIGURATION}, - "toolConfig": {"target": TOOL_CONFIGURATION}, - "guardrailConfig": {"target": GUARDRAIL_STREAM_CONFIGURATION}, - "additionalModelRequestFields": {"target": DOCUMENT}, - "promptVariables": {"target": PROMPT_VARIABLE_MAP}, - "additionalModelResponseFieldPaths": { - "target": ADDITIONAL_MODEL_RESPONSE_FIELD_PATHS - }, - "requestMetadata": {"target": REQUEST_METADATA}, - "performanceConfig": {"target": PERFORMANCE_CONFIGURATION}, - "serviceTier": {"target": SERVICE_TIER}, - "outputConfig": {"target": OUTPUT_CONFIG}, - }, -) - -NON_NEGATIVE_INTEGER = Schema( - id=ShapeID("com.amazonaws.bedrockruntime#NonNegativeInteger"), - shape_type=ShapeType.INTEGER, -) - -CITATION_SOURCE_CONTENT_DELTA = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#CitationSourceContentDelta"), - members={"text": {"target": STRING}}, -) - -CITATION_SOURCE_CONTENT_LIST_DELTA = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#CitationSourceContentListDelta"), - shape_type=ShapeType.LIST, - members={"member": {"target": CITATION_SOURCE_CONTENT_DELTA}}, -) - -CITATIONS_DELTA = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#CitationsDelta"), - members={ - "title": {"target": STRING}, - "source": {"target": STRING}, - "sourceContent": {"target": CITATION_SOURCE_CONTENT_LIST_DELTA}, - "location": {"target": CITATION_LOCATION}, - }, -) - -IMAGE_BLOCK_DELTA = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#ImageBlockDelta"), - members={"source": {"target": IMAGE_SOURCE}, "error": {"target": ERROR_BLOCK}}, -) - -REASONING_CONTENT_BLOCK_DELTA = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#ReasoningContentBlockDelta"), - shape_type=ShapeType.UNION, - traits=[Trait.new(id=ShapeID("smithy.api#sensitive"))], - members={ - "text": {"target": STRING}, - "redactedContent": {"target": BLOB}, - "signature": {"target": STRING}, - }, -) - -TOOL_RESULT_BLOCK_DELTA = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#ToolResultBlockDelta"), - shape_type=ShapeType.UNION, - members={"text": {"target": STRING}, "json": {"target": DOCUMENT}}, -) - -TOOL_RESULT_BLOCKS_DELTA = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#ToolResultBlocksDelta"), - shape_type=ShapeType.LIST, - members={"member": {"target": TOOL_RESULT_BLOCK_DELTA}}, -) - -TOOL_USE_BLOCK_DELTA = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#ToolUseBlockDelta"), - members={ - "input": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - } - }, -) - -CONTENT_BLOCK_DELTA = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#ContentBlockDelta"), - shape_type=ShapeType.UNION, - members={ - "text": {"target": STRING}, - "toolUse": {"target": TOOL_USE_BLOCK_DELTA}, - "toolResult": {"target": TOOL_RESULT_BLOCKS_DELTA}, - "reasoningContent": {"target": REASONING_CONTENT_BLOCK_DELTA}, - "citation": {"target": CITATIONS_DELTA}, - "image": {"target": IMAGE_BLOCK_DELTA}, - }, -) - -CONTENT_BLOCK_DELTA_EVENT = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#ContentBlockDeltaEvent"), - members={ - "delta": { - "target": CONTENT_BLOCK_DELTA, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - "contentBlockIndex": { - "target": NON_NEGATIVE_INTEGER, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - }, -) - -IMAGE_BLOCK_START = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#ImageBlockStart"), - members={ - "format": { - "target": IMAGE_FORMAT, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - } - }, -) - -TOOL_RESULT_BLOCK_START = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#ToolResultBlockStart"), - members={ - "toolUseId": { - "target": TOOL_USE_ID, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - "type": {"target": STRING}, - "status": {"target": TOOL_RESULT_STATUS}, - }, -) - -TOOL_USE_BLOCK_START = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#ToolUseBlockStart"), - members={ - "toolUseId": { - "target": TOOL_USE_ID, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - "name": { - "target": TOOL_NAME, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - "type": {"target": TOOL_USE_TYPE}, - }, -) - -CONTENT_BLOCK_START = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#ContentBlockStart"), - shape_type=ShapeType.UNION, - members={ - "toolUse": {"target": TOOL_USE_BLOCK_START}, - "toolResult": {"target": TOOL_RESULT_BLOCK_START}, - "image": {"target": IMAGE_BLOCK_START}, - }, -) - -CONTENT_BLOCK_START_EVENT = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#ContentBlockStartEvent"), - members={ - "start": { - "target": CONTENT_BLOCK_START, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - "contentBlockIndex": { - "target": NON_NEGATIVE_INTEGER, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - }, -) - -CONTENT_BLOCK_STOP_EVENT = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#ContentBlockStopEvent"), - members={ - "contentBlockIndex": { - "target": NON_NEGATIVE_INTEGER, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - } - }, -) - -MESSAGE_START_EVENT = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#MessageStartEvent"), - members={ - "role": { - "target": CONVERSATION_ROLE, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - } - }, -) - -MESSAGE_STOP_EVENT = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#MessageStopEvent"), - members={ - "stopReason": { - "target": STOP_REASON, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - "additionalModelResponseFields": {"target": DOCUMENT}, - }, -) - -CONVERSE_STREAM_METRICS = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#ConverseStreamMetrics"), - members={ - "latencyMs": { - "target": LONG, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - } - }, -) - -CONVERSE_STREAM_TRACE = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#ConverseStreamTrace"), - members={ - "guardrail": {"target": GUARDRAIL_TRACE_ASSESSMENT}, - "promptRouter": {"target": PROMPT_ROUTER_TRACE}, - }, -) - -CONVERSE_STREAM_METADATA_EVENT = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#ConverseStreamMetadataEvent"), - members={ - "usage": { - "target": TOKEN_USAGE, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - "metrics": { - "target": CONVERSE_STREAM_METRICS, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - "trace": {"target": CONVERSE_STREAM_TRACE}, - "performanceConfig": {"target": PERFORMANCE_CONFIGURATION}, - "serviceTier": {"target": SERVICE_TIER}, - }, -) - -MODEL_STREAM_ERROR_EXCEPTION = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#ModelStreamErrorException"), - traits=[ - Trait.new(id=ShapeID("smithy.api#error"), value="client"), - Trait.new(id=ShapeID("smithy.api#httpError"), value=424), - ], - members={ - "message": {"target": NON_BLANK_STRING}, - "originalStatusCode": {"target": STATUS_CODE}, - "originalMessage": {"target": NON_BLANK_STRING}, - }, -) - -CONVERSE_STREAM_OUTPUT = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#ConverseStreamOutput"), - shape_type=ShapeType.UNION, - traits=[Trait.new(id=ShapeID("smithy.api#streaming"))], - members={ - "messageStart": {"target": MESSAGE_START_EVENT}, - "contentBlockStart": {"target": CONTENT_BLOCK_START_EVENT}, - "contentBlockDelta": {"target": CONTENT_BLOCK_DELTA_EVENT}, - "contentBlockStop": {"target": CONTENT_BLOCK_STOP_EVENT}, - "messageStop": {"target": MESSAGE_STOP_EVENT}, - "metadata": {"target": CONVERSE_STREAM_METADATA_EVENT}, - "internalServerException": {"target": INTERNAL_SERVER_EXCEPTION}, - "modelStreamErrorException": {"target": MODEL_STREAM_ERROR_EXCEPTION}, - "validationException": {"target": VALIDATION_EXCEPTION}, - "throttlingException": {"target": THROTTLING_EXCEPTION}, - "serviceUnavailableException": {"target": SERVICE_UNAVAILABLE_EXCEPTION}, - }, -) - -CONVERSE_STREAM_OPERATION_OUTPUT = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#ConverseStreamOperationOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="com.amazonaws.bedrockruntime#ConverseStreamResponse", - ) - ], - members={ - "stream": { - "target": CONVERSE_STREAM_OUTPUT, - "traits": [Trait.new(id=ShapeID("smithy.api#httpPayload"))], - } - }, -) - -CONVERSE_STREAM = Schema( - id=ShapeID("com.amazonaws.bedrockruntime#ConverseStream"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType( - { - "code": 200, - "method": "POST", - "uri": "/model/{modelId}/converse-stream", - } - ), - ) - ], -) - -MIME_TYPE = Schema( - id=ShapeID("com.amazonaws.bedrockruntime#MimeType"), shape_type=ShapeType.STRING -) - -BODY = Schema( - id=ShapeID("com.amazonaws.bedrockruntime#Body"), - shape_type=ShapeType.BLOB, - traits=[Trait.new(id=ShapeID("smithy.api#sensitive"))], -) - -INVOKE_MODEL_IDENTIFIER = Schema( - id=ShapeID("com.amazonaws.bedrockruntime#InvokeModelIdentifier"), - shape_type=ShapeType.STRING, -) - -REQUEST_METADATA_JSON = Schema( - id=ShapeID("com.amazonaws.bedrockruntime#RequestMetadataJson"), - shape_type=ShapeType.STRING, - traits=[Trait.new(id=ShapeID("smithy.api#sensitive"))], -) - -TRACE = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#Trace"), - shape_type=ShapeType.ENUM, - members={ - "ENABLED": {"target": UNIT}, - "DISABLED": {"target": UNIT}, - "ENABLED_FULL": {"target": UNIT}, - }, -) - -INVOKE_MODEL_INPUT = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#InvokeModelInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="com.amazonaws.bedrockruntime#InvokeModelRequest", - ) - ], - members={ - "body": { - "target": BODY, - "traits": [Trait.new(id=ShapeID("smithy.api#httpPayload"))], - }, - "contentType": { - "target": MIME_TYPE, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpHeader"), value="Content-Type") - ], - }, - "accept": { - "target": MIME_TYPE, - "traits": [Trait.new(id=ShapeID("smithy.api#httpHeader"), value="Accept")], - }, - "modelId": { - "target": INVOKE_MODEL_IDENTIFIER, - "traits": [ - Trait.new(id=ShapeID("smithy.api#required")), - Trait.new(id=ShapeID("smithy.api#httpLabel")), - ], - }, - "trace": { - "target": TRACE, - "traits": [ - Trait.new( - id=ShapeID("smithy.api#httpHeader"), value="X-Amzn-Bedrock-Trace" - ) - ], - }, - "guardrailIdentifier": { - "target": GUARDRAIL_IDENTIFIER, - "traits": [ - Trait.new( - id=ShapeID("smithy.api#httpHeader"), - value="X-Amzn-Bedrock-GuardrailIdentifier", - ) - ], - }, - "guardrailVersion": { - "target": GUARDRAIL_VERSION, - "traits": [ - Trait.new( - id=ShapeID("smithy.api#httpHeader"), - value="X-Amzn-Bedrock-GuardrailVersion", - ) - ], - }, - "performanceConfigLatency": { - "target": PERFORMANCE_CONFIG_LATENCY, - "traits": [ - Trait.new(id=ShapeID("smithy.api#default"), value="standard"), - Trait.new( - id=ShapeID("smithy.api#httpHeader"), - value="X-Amzn-Bedrock-PerformanceConfig-Latency", - ), - ], - }, - "serviceTier": { - "target": SERVICE_TIER_TYPE, - "traits": [ - Trait.new( - id=ShapeID("smithy.api#httpHeader"), - value="X-Amzn-Bedrock-Service-Tier", - ) - ], - }, - "requestMetadata": { - "target": REQUEST_METADATA_JSON, - "traits": [ - Trait.new( - id=ShapeID("smithy.api#httpHeader"), - value="X-Amzn-Bedrock-Request-Metadata", - ) - ], - }, - }, -) - -INVOKE_MODEL_OUTPUT = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#InvokeModelOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="com.amazonaws.bedrockruntime#InvokeModelResponse", - ) - ], - members={ - "body": { - "target": BODY, - "traits": [ - Trait.new(id=ShapeID("smithy.api#required")), - Trait.new(id=ShapeID("smithy.api#httpPayload")), - ], - }, - "contentType": { - "target": MIME_TYPE, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpHeader"), value="Content-Type"), - Trait.new(id=ShapeID("smithy.api#required")), - ], - }, - "performanceConfigLatency": { - "target": PERFORMANCE_CONFIG_LATENCY, - "traits": [ - Trait.new( - id=ShapeID("smithy.api#httpHeader"), - value="X-Amzn-Bedrock-PerformanceConfig-Latency", - ) - ], - }, - "serviceTier": { - "target": SERVICE_TIER_TYPE, - "traits": [ - Trait.new( - id=ShapeID("smithy.api#httpHeader"), - value="X-Amzn-Bedrock-Service-Tier", - ) - ], - }, - }, -) - -INVOKE_MODEL = Schema( - id=ShapeID("com.amazonaws.bedrockruntime#InvokeModel"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType( - {"code": 200, "method": "POST", "uri": "/model/{modelId}/invoke"} - ), - ) - ], -) - -PART_BODY = Schema( - id=ShapeID("com.amazonaws.bedrockruntime#PartBody"), - shape_type=ShapeType.BLOB, - traits=[Trait.new(id=ShapeID("smithy.api#sensitive"))], -) - -BIDIRECTIONAL_INPUT_PAYLOAD_PART = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#BidirectionalInputPayloadPart"), - traits=[Trait.new(id=ShapeID("smithy.api#sensitive"))], - members={"bytes": {"target": PART_BODY}}, -) - -INVOKE_MODEL_WITH_BIDIRECTIONAL_STREAM_INPUT = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#InvokeModelWithBidirectionalStreamInput"), - shape_type=ShapeType.UNION, - traits=[Trait.new(id=ShapeID("smithy.api#streaming"))], - members={"chunk": {"target": BIDIRECTIONAL_INPUT_PAYLOAD_PART}}, -) - -INVOKE_MODEL_WITH_BIDIRECTIONAL_STREAM_OPERATION_INPUT = Schema.collection( - id=ShapeID( - "com.amazonaws.bedrockruntime#InvokeModelWithBidirectionalStreamOperationInput" - ), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="com.amazonaws.bedrockruntime#InvokeModelWithBidirectionalStreamRequest", - ) - ], - members={ - "modelId": { - "target": INVOKE_MODEL_IDENTIFIER, - "traits": [ - Trait.new(id=ShapeID("smithy.api#required")), - Trait.new(id=ShapeID("smithy.api#httpLabel")), - ], - }, - "body": { - "target": INVOKE_MODEL_WITH_BIDIRECTIONAL_STREAM_INPUT, - "traits": [ - Trait.new(id=ShapeID("smithy.api#required")), - Trait.new(id=ShapeID("smithy.api#httpPayload")), - ], - }, - }, -) - -BIDIRECTIONAL_OUTPUT_PAYLOAD_PART = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#BidirectionalOutputPayloadPart"), - traits=[Trait.new(id=ShapeID("smithy.api#sensitive"))], - members={"bytes": {"target": PART_BODY}}, -) - -INVOKE_MODEL_WITH_BIDIRECTIONAL_STREAM_OUTPUT = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#InvokeModelWithBidirectionalStreamOutput"), - shape_type=ShapeType.UNION, - traits=[Trait.new(id=ShapeID("smithy.api#streaming"))], - members={ - "chunk": {"target": BIDIRECTIONAL_OUTPUT_PAYLOAD_PART}, - "internalServerException": {"target": INTERNAL_SERVER_EXCEPTION}, - "modelStreamErrorException": {"target": MODEL_STREAM_ERROR_EXCEPTION}, - "validationException": {"target": VALIDATION_EXCEPTION}, - "throttlingException": {"target": THROTTLING_EXCEPTION}, - "modelTimeoutException": {"target": MODEL_TIMEOUT_EXCEPTION}, - "serviceUnavailableException": {"target": SERVICE_UNAVAILABLE_EXCEPTION}, - }, -) - -INVOKE_MODEL_WITH_BIDIRECTIONAL_STREAM_OPERATION_OUTPUT = Schema.collection( - id=ShapeID( - "com.amazonaws.bedrockruntime#InvokeModelWithBidirectionalStreamOperationOutput" - ), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="com.amazonaws.bedrockruntime#InvokeModelWithBidirectionalStreamResponse", - ) - ], - members={ - "body": { - "target": INVOKE_MODEL_WITH_BIDIRECTIONAL_STREAM_OUTPUT, - "traits": [ - Trait.new(id=ShapeID("smithy.api#required")), - Trait.new(id=ShapeID("smithy.api#httpPayload")), - ], - } - }, -) - -INVOKE_MODEL_WITH_BIDIRECTIONAL_STREAM = Schema( - id=ShapeID("com.amazonaws.bedrockruntime#InvokeModelWithBidirectionalStream"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType( - { - "code": 200, - "method": "POST", - "uri": "/model/{modelId}/invoke-with-bidirectional-stream", - } - ), - ) - ], -) - -INVOKE_MODEL_WITH_RESPONSE_STREAM_INPUT = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#InvokeModelWithResponseStreamInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="com.amazonaws.bedrockruntime#InvokeModelWithResponseStreamRequest", - ) - ], - members={ - "body": { - "target": BODY, - "traits": [Trait.new(id=ShapeID("smithy.api#httpPayload"))], - }, - "contentType": { - "target": MIME_TYPE, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpHeader"), value="Content-Type") - ], - }, - "accept": { - "target": MIME_TYPE, - "traits": [ - Trait.new( - id=ShapeID("smithy.api#httpHeader"), value="X-Amzn-Bedrock-Accept" - ) - ], - }, - "modelId": { - "target": INVOKE_MODEL_IDENTIFIER, - "traits": [ - Trait.new(id=ShapeID("smithy.api#required")), - Trait.new(id=ShapeID("smithy.api#httpLabel")), - ], - }, - "trace": { - "target": TRACE, - "traits": [ - Trait.new( - id=ShapeID("smithy.api#httpHeader"), value="X-Amzn-Bedrock-Trace" - ) - ], - }, - "guardrailIdentifier": { - "target": GUARDRAIL_IDENTIFIER, - "traits": [ - Trait.new( - id=ShapeID("smithy.api#httpHeader"), - value="X-Amzn-Bedrock-GuardrailIdentifier", - ) - ], - }, - "guardrailVersion": { - "target": GUARDRAIL_VERSION, - "traits": [ - Trait.new( - id=ShapeID("smithy.api#httpHeader"), - value="X-Amzn-Bedrock-GuardrailVersion", - ) - ], - }, - "performanceConfigLatency": { - "target": PERFORMANCE_CONFIG_LATENCY, - "traits": [ - Trait.new(id=ShapeID("smithy.api#default"), value="standard"), - Trait.new( - id=ShapeID("smithy.api#httpHeader"), - value="X-Amzn-Bedrock-PerformanceConfig-Latency", - ), - ], - }, - "serviceTier": { - "target": SERVICE_TIER_TYPE, - "traits": [ - Trait.new( - id=ShapeID("smithy.api#httpHeader"), - value="X-Amzn-Bedrock-Service-Tier", - ) - ], - }, - "requestMetadata": { - "target": REQUEST_METADATA_JSON, - "traits": [ - Trait.new( - id=ShapeID("smithy.api#httpHeader"), - value="X-Amzn-Bedrock-Request-Metadata", - ) - ], - }, - }, -) - -PAYLOAD_PART = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#PayloadPart"), - traits=[Trait.new(id=ShapeID("smithy.api#sensitive"))], - members={"bytes": {"target": PART_BODY}}, -) - -RESPONSE_STREAM = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#ResponseStream"), - shape_type=ShapeType.UNION, - traits=[Trait.new(id=ShapeID("smithy.api#streaming"))], - members={ - "chunk": {"target": PAYLOAD_PART}, - "internalServerException": {"target": INTERNAL_SERVER_EXCEPTION}, - "modelStreamErrorException": {"target": MODEL_STREAM_ERROR_EXCEPTION}, - "validationException": {"target": VALIDATION_EXCEPTION}, - "throttlingException": {"target": THROTTLING_EXCEPTION}, - "modelTimeoutException": {"target": MODEL_TIMEOUT_EXCEPTION}, - "serviceUnavailableException": {"target": SERVICE_UNAVAILABLE_EXCEPTION}, - }, -) - -INVOKE_MODEL_WITH_RESPONSE_STREAM_OUTPUT = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#InvokeModelWithResponseStreamOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="com.amazonaws.bedrockruntime#InvokeModelWithResponseStreamResponse", - ) - ], - members={ - "body": { - "target": RESPONSE_STREAM, - "traits": [ - Trait.new(id=ShapeID("smithy.api#required")), - Trait.new(id=ShapeID("smithy.api#httpPayload")), - ], - }, - "contentType": { - "target": MIME_TYPE, - "traits": [ - Trait.new( - id=ShapeID("smithy.api#httpHeader"), - value="X-Amzn-Bedrock-Content-Type", - ), - Trait.new(id=ShapeID("smithy.api#required")), - ], - }, - "performanceConfigLatency": { - "target": PERFORMANCE_CONFIG_LATENCY, - "traits": [ - Trait.new( - id=ShapeID("smithy.api#httpHeader"), - value="X-Amzn-Bedrock-PerformanceConfig-Latency", - ) - ], - }, - "serviceTier": { - "target": SERVICE_TIER_TYPE, - "traits": [ - Trait.new( - id=ShapeID("smithy.api#httpHeader"), - value="X-Amzn-Bedrock-Service-Tier", - ) - ], - }, - }, -) - -INVOKE_MODEL_WITH_RESPONSE_STREAM = Schema( - id=ShapeID("com.amazonaws.bedrockruntime#InvokeModelWithResponseStream"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType( - { - "code": 200, - "method": "POST", - "uri": "/model/{modelId}/invoke-with-response-stream", - } - ), - ) - ], -) - -CONVERSE_TOKENS_REQUEST = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#ConverseTokensRequest"), - members={ - "messages": {"target": MESSAGES}, - "system": {"target": SYSTEM_CONTENT_BLOCKS}, - "toolConfig": {"target": TOOL_CONFIGURATION}, - "additionalModelRequestFields": {"target": DOCUMENT}, - }, -) - -INVOKE_MODEL_TOKENS_REQUEST = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#InvokeModelTokensRequest"), - members={ - "body": { - "target": BODY, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - } - }, -) - -COUNT_TOKENS_INPUT = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#CountTokensInput"), - shape_type=ShapeType.UNION, - members={ - "invokeModel": {"target": INVOKE_MODEL_TOKENS_REQUEST}, - "converse": {"target": CONVERSE_TOKENS_REQUEST}, - }, -) - -FOUNDATION_MODEL_VERSION_IDENTIFIER = Schema( - id=ShapeID("com.amazonaws.bedrockruntime#FoundationModelVersionIdentifier"), - shape_type=ShapeType.STRING, -) - -COUNT_TOKENS_OPERATION_INPUT = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#CountTokensOperationInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="com.amazonaws.bedrockruntime#CountTokensRequest", - ) - ], - members={ - "modelId": { - "target": FOUNDATION_MODEL_VERSION_IDENTIFIER, - "traits": [ - Trait.new(id=ShapeID("smithy.api#required")), - Trait.new(id=ShapeID("smithy.api#httpLabel")), - ], - }, - "input": { - "target": COUNT_TOKENS_INPUT, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - }, -) - -COUNT_TOKENS_OUTPUT = Schema.collection( - id=ShapeID("com.amazonaws.bedrockruntime#CountTokensOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="com.amazonaws.bedrockruntime#CountTokensResponse", - ) - ], - members={ - "inputTokens": { - "target": INTEGER, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - } - }, -) - -COUNT_TOKENS = Schema( - id=ShapeID("com.amazonaws.bedrockruntime#CountTokens"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType( - {"code": 200, "method": "POST", "uri": "/model/{modelId}/count-tokens"} - ), - ) - ], -) - -AMAZON_BEDROCK_FRONTEND_SERVICE = Schema( - id=ShapeID("com.amazonaws.bedrockruntime#AmazonBedrockFrontendService"), - shape_type=ShapeType.SERVICE, - traits=[ - Trait.new( - id=ShapeID("aws.auth#sigv4"), value=MappingProxyType({"name": "bedrock"}) - ), - Trait.new( - id=ShapeID("smithy.rules#endpointBdd"), - value=MappingProxyType( - { - "version": "1.1", - "parameters": MappingProxyType( - { - "Region": MappingProxyType( - { - "builtIn": "AWS::Region", - "required": False, - "documentation": "The AWS region used to dispatch the request.", - "type": "string", - } - ), - "UseDualStack": MappingProxyType( - { - "builtIn": "AWS::UseDualStack", - "required": True, - "default": False, - "documentation": "When true, use the dual-stack endpoint. If the configured endpoint does not support dual-stack, dispatching the request MAY return an error.", - "type": "boolean", - } - ), - "UseFIPS": MappingProxyType( - { - "builtIn": "AWS::UseFIPS", - "required": True, - "default": False, - "documentation": "When true, send this request to the FIPS-compliant regional endpoint. If the configured endpoint does not have a FIPS compliant endpoint, dispatching the request will return an error.", - "type": "boolean", - } - ), - "Endpoint": MappingProxyType( - { - "builtIn": "SDK::Endpoint", - "required": False, - "documentation": "Override the endpoint used to send this request", - "type": "string", - } - ), - } - ), - "conditions": ( - MappingProxyType( +AMAZON_BEDROCK_FRONTEND_SERVICE: StaticSchema = ( + 21, + n0, + _ABFS, + { + _aw: MappingProxyType({"name": "bedrock"}), + _sBm: MappingProxyType( + { + "version": "1.1", + "parameters": MappingProxyType( + { + "Region": MappingProxyType( { - "fn": "isSet", - "argv": (MappingProxyType({"ref": "Endpoint"}),), + "builtIn": "AWS::Region", + "required": False, + "documentation": "The AWS region used to dispatch the request.", + "type": "string", } ), - MappingProxyType( + "UseDualStack": MappingProxyType( { - "fn": "isSet", - "argv": (MappingProxyType({"ref": "Region"}),), + "builtIn": "AWS::UseDualStack", + "required": True, + "default": False, + "documentation": "When true, use the dual-stack endpoint. If the configured endpoint does not support dual-stack, dispatching the request MAY return an error.", + "type": "boolean", } ), - MappingProxyType( + "UseFIPS": MappingProxyType( { - "fn": "aws.partition", - "argv": (MappingProxyType({"ref": "Region"}),), - "assign": "PartitionResult", + "builtIn": "AWS::UseFIPS", + "required": True, + "default": False, + "documentation": "When true, send this request to the FIPS-compliant regional endpoint. If the configured endpoint does not have a FIPS compliant endpoint, dispatching the request will return an error.", + "type": "boolean", } ), - MappingProxyType( + "Endpoint": MappingProxyType( { - "fn": "booleanEquals", - "argv": (MappingProxyType({"ref": "UseFIPS"}), True), - } - ), - MappingProxyType( - { - "fn": "booleanEquals", - "argv": ( - MappingProxyType({"ref": "UseDualStack"}), - True, - ), - } - ), - MappingProxyType( - { - "fn": "booleanEquals", - "argv": ( - MappingProxyType( - { - "fn": "getAttr", - "argv": ( - MappingProxyType( - {"ref": "PartitionResult"} - ), - "supportsDualStack", - ), - } - ), - True, - ), - } - ), - MappingProxyType( - { - "fn": "booleanEquals", - "argv": ( - MappingProxyType( - { - "fn": "getAttr", - "argv": ( - MappingProxyType( - {"ref": "PartitionResult"} - ), - "supportsFIPS", - ), - } - ), - True, - ), + "builtIn": "SDK::Endpoint", + "required": False, + "documentation": "Override the endpoint used to send this request", + "type": "string", } ), + } + ), + "conditions": ( + MappingProxyType( + { + "fn": "isSet", + "argv": (MappingProxyType({"ref": "Endpoint"}),), + } ), - "results": ( - MappingProxyType( - { - "conditions": (), - "error": "Invalid Configuration: FIPS and custom endpoint are not supported", - "type": "error", - } - ), - MappingProxyType( - { - "conditions": (), - "error": "Invalid Configuration: Dualstack and custom endpoint are not supported", - "type": "error", - } - ), - MappingProxyType( - { - "conditions": (), - "endpoint": MappingProxyType( - { - "url": MappingProxyType({"ref": "Endpoint"}), - "properties": MappingProxyType({}), - "headers": MappingProxyType({}), - } - ), - "type": "endpoint", - } - ), - MappingProxyType( - { - "conditions": (), - "endpoint": MappingProxyType( - { - "url": "https://bedrock-runtime-fips.{Region}.{PartitionResult#dualStackDnsSuffix}", - "properties": MappingProxyType({}), - "headers": MappingProxyType({}), - } - ), - "type": "endpoint", - } - ), - MappingProxyType( - { - "conditions": (), - "error": "FIPS and DualStack are enabled, but this partition does not support one or both", - "type": "error", - } - ), - MappingProxyType( - { - "conditions": (), - "endpoint": MappingProxyType( - { - "url": "https://bedrock-runtime-fips.{Region}.{PartitionResult#dnsSuffix}", - "properties": MappingProxyType({}), - "headers": MappingProxyType({}), - } - ), - "type": "endpoint", - } - ), - MappingProxyType( - { - "conditions": (), - "error": "FIPS is enabled but this partition does not support FIPS", - "type": "error", - } - ), - MappingProxyType( - { - "conditions": (), - "endpoint": MappingProxyType( + MappingProxyType( + {"fn": "isSet", "argv": (MappingProxyType({"ref": "Region"}),)} + ), + MappingProxyType( + { + "fn": "aws.partition", + "argv": (MappingProxyType({"ref": "Region"}),), + "assign": "PartitionResult", + } + ), + MappingProxyType( + { + "fn": "booleanEquals", + "argv": (MappingProxyType({"ref": "UseFIPS"}), True), + } + ), + MappingProxyType( + { + "fn": "booleanEquals", + "argv": (MappingProxyType({"ref": "UseDualStack"}), True), + } + ), + MappingProxyType( + { + "fn": "booleanEquals", + "argv": ( + MappingProxyType( { - "url": "https://bedrock-runtime.{Region}.{PartitionResult#dualStackDnsSuffix}", - "properties": MappingProxyType({}), - "headers": MappingProxyType({}), + "fn": "getAttr", + "argv": ( + MappingProxyType( + {"ref": "PartitionResult"} + ), + "supportsDualStack", + ), } ), - "type": "endpoint", - } - ), - MappingProxyType( - { - "conditions": (), - "error": "DualStack is enabled but this partition does not support DualStack", - "type": "error", - } - ), - MappingProxyType( - { - "conditions": (), - "endpoint": MappingProxyType( + True, + ), + } + ), + MappingProxyType( + { + "fn": "booleanEquals", + "argv": ( + MappingProxyType( { - "url": "https://bedrock-runtime.{Region}.{PartitionResult#dnsSuffix}", - "properties": MappingProxyType({}), - "headers": MappingProxyType({}), + "fn": "getAttr", + "argv": ( + MappingProxyType( + {"ref": "PartitionResult"} + ), + "supportsFIPS", + ), } ), - "type": "endpoint", - } - ), - MappingProxyType( - { - "conditions": (), - "error": "Invalid Configuration: Missing Region", - "type": "error", - } - ), + True, + ), + } + ), + ), + "results": ( + MappingProxyType( + { + "conditions": (), + "error": "Invalid Configuration: FIPS and custom endpoint are not supported", + "type": "error", + } ), - "root": 2, - "nodeCount": 13, - "nodes": "/////wAAAAH/////AAAAAAAAAAwAAAADAAAAAQAAAAQF9eELAAAAAgAAAAUF9eELAAAAAwAAAAgAAAAGAAAABAAAAAcF9eEKAAAABQX14QgF9eEJAAAABAAAAAoAAAAJAAAABgX14QYF9eEHAAAABQAAAAsF9eEFAAAABgX14QQF9eEFAAAAAwX14QEAAAANAAAABAX14QIF9eED", - } - ), + MappingProxyType( + { + "conditions": (), + "error": "Invalid Configuration: Dualstack and custom endpoint are not supported", + "type": "error", + } + ), + MappingProxyType( + { + "conditions": (), + "endpoint": MappingProxyType( + { + "url": MappingProxyType({"ref": "Endpoint"}), + "properties": MappingProxyType[str, object]({}), + "headers": MappingProxyType[str, object]({}), + } + ), + "type": "endpoint", + } + ), + MappingProxyType( + { + "conditions": (), + "endpoint": MappingProxyType( + { + "url": "https://bedrock-runtime-fips.{Region}.{PartitionResult#dualStackDnsSuffix}", + "properties": MappingProxyType[str, object]({}), + "headers": MappingProxyType[str, object]({}), + } + ), + "type": "endpoint", + } + ), + MappingProxyType( + { + "conditions": (), + "error": "FIPS and DualStack are enabled, but this partition does not support one or both", + "type": "error", + } + ), + MappingProxyType( + { + "conditions": (), + "endpoint": MappingProxyType( + { + "url": "https://bedrock-runtime-fips.{Region}.{PartitionResult#dnsSuffix}", + "properties": MappingProxyType[str, object]({}), + "headers": MappingProxyType[str, object]({}), + } + ), + "type": "endpoint", + } + ), + MappingProxyType( + { + "conditions": (), + "error": "FIPS is enabled but this partition does not support FIPS", + "type": "error", + } + ), + MappingProxyType( + { + "conditions": (), + "endpoint": MappingProxyType( + { + "url": "https://bedrock-runtime.{Region}.{PartitionResult#dualStackDnsSuffix}", + "properties": MappingProxyType[str, object]({}), + "headers": MappingProxyType[str, object]({}), + } + ), + "type": "endpoint", + } + ), + MappingProxyType( + { + "conditions": (), + "error": "DualStack is enabled but this partition does not support DualStack", + "type": "error", + } + ), + MappingProxyType( + { + "conditions": (), + "endpoint": MappingProxyType( + { + "url": "https://bedrock-runtime.{Region}.{PartitionResult#dnsSuffix}", + "properties": MappingProxyType[str, object]({}), + "headers": MappingProxyType[str, object]({}), + } + ), + "type": "endpoint", + } + ), + MappingProxyType( + { + "conditions": (), + "error": "Invalid Configuration: Missing Region", + "type": "error", + } + ), + ), + "root": 2, + "nodeCount": 13, + "nodes": "/////wAAAAH/////AAAAAAAAAAwAAAADAAAAAQAAAAQF9eELAAAAAgAAAAUF9eELAAAAAwAAAAgAAAAGAAAABAAAAAcF9eEKAAAABQX14QgF9eEJAAAABAAAAAoAAAAJAAAABgX14QYF9eEHAAAABQAAAAsF9eEFAAAABgX14QQF9eEFAAAAAwX14QEAAAANAAAABAX14QIF9eED", + } ), - Trait.new( - id=ShapeID("aws.api#service"), - value=MappingProxyType( - { - "sdkId": "Bedrock Runtime", - "endpointPrefix": "bedrock-runtime", - "cloudTrailEventSource": "bedrock.amazonaws.com", - } - ), + _aws: MappingProxyType( + { + "sdkId": "Bedrock Runtime", + "endpointPrefix": "bedrock-runtime", + "cloudTrailEventSource": "bedrock.amazonaws.com", + } ), - Trait.new( - id=ShapeID("aws.protocols#restJson1"), - value=MappingProxyType( - {"http": ("h2", "http/1.1"), "eventStreamHttp": ("h2", "http/1.1")} - ), + _aJ: MappingProxyType( + {"http": ("h2", "http/1.1"), "eventStreamHttp": ("h2", "http/1.1")} ), - Trait.new(id=ShapeID("smithy.api#httpBearerAuth")), - ], + _sBA: None, + }, ) diff --git a/clients/aws-sdk-bedrock-runtime/src/aws_sdk_bedrock_runtime/models.py b/clients/aws-sdk-bedrock-runtime/src/aws_sdk_bedrock_runtime/models.py index 03cb9490..c3ebd68a 100644 --- a/clients/aws-sdk-bedrock-runtime/src/aws_sdk_bedrock_runtime/models.py +++ b/clients/aws-sdk-bedrock-runtime/src/aws_sdk_bedrock_runtime/models.py @@ -6,6 +6,7 @@ import logging from typing import Any, Literal, Self, Union +from smithy_core._schema_compact import hydrate from smithy_core.deserializers import ShapeDeserializer from smithy_core.documents import Document, TypeRegistry from smithy_core.exceptions import ModeledError, SerializationError @@ -247,13 +248,12 @@ class AccessDeniedException(ServiceError): fault: Literal["client", "server"] | None = "client" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_ACCESS_DENIED_EXCEPTION, self) + serializer.write_struct(hydrate(_SCHEMA_ACCESS_DENIED_EXCEPTION), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_ACCESS_DENIED_EXCEPTION).members_by_index if self.message is not None: - serializer.write_string( - _SCHEMA_ACCESS_DENIED_EXCEPTION.members["message"], self.message - ) + serializer.write_string(members[0], self.message) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -262,25 +262,25 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_ACCESS_DENIED_EXCEPTION) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["message"] = de.read_string( - _SCHEMA_ACCESS_DENIED_EXCEPTION.members["message"] - ) + kwargs["message"] = de.read_string(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_ACCESS_DENIED_EXCEPTION, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs def _serialize_additional_model_response_field_paths( serializer: ShapeSerializer, schema: Schema, value: list[str] ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_string(member_schema, e) @@ -290,7 +290,7 @@ def _deserialize_additional_model_response_field_paths( deserializer: ShapeDeserializer, schema: Schema ) -> list[str]: result: list[str] = [] - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] def _read_value(d: ShapeDeserializer): if d.is_null(): @@ -311,14 +311,12 @@ class GetAsyncInvokeInput: """The invocation's ARN.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_GET_ASYNC_INVOKE_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_GET_ASYNC_INVOKE_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_GET_ASYNC_INVOKE_INPUT).members_by_index if self.invocation_arn is not None: - serializer.write_string( - _SCHEMA_GET_ASYNC_INVOKE_INPUT.members["invocationArn"], - self.invocation_arn, - ) + serializer.write_string(members[0], self.invocation_arn) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -327,18 +325,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_GET_ASYNC_INVOKE_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["invocation_arn"] = de.read_string( - _SCHEMA_GET_ASYNC_INVOKE_INPUT.members["invocationArn"] - ) + kwargs["invocation_arn"] = de.read_string(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_GET_ASYNC_INVOKE_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -359,23 +357,18 @@ class AsyncInvokeS3OutputDataConfig: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_ASYNC_INVOKE_S3_OUTPUT_DATA_CONFIG, self) + serializer.write_struct( + hydrate(_SCHEMA_ASYNC_INVOKE_S3_OUTPUT_DATA_CONFIG), self + ) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_string( - _SCHEMA_ASYNC_INVOKE_S3_OUTPUT_DATA_CONFIG.members["s3Uri"], self.s3_uri - ) + members = hydrate(_SCHEMA_ASYNC_INVOKE_S3_OUTPUT_DATA_CONFIG).members_by_index + serializer.write_string(members[0], self.s3_uri) if self.kms_key_id is not None: - serializer.write_string( - _SCHEMA_ASYNC_INVOKE_S3_OUTPUT_DATA_CONFIG.members["kmsKeyId"], - self.kms_key_id, - ) + serializer.write_string(members[1], self.kms_key_id) if self.bucket_owner is not None: - serializer.write_string( - _SCHEMA_ASYNC_INVOKE_S3_OUTPUT_DATA_CONFIG.members["bucketOwner"], - self.bucket_owner, - ) + serializer.write_string(members[2], self.bucket_owner) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -384,32 +377,24 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_ASYNC_INVOKE_S3_OUTPUT_DATA_CONFIG) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["s3_uri"] = de.read_string( - _SCHEMA_ASYNC_INVOKE_S3_OUTPUT_DATA_CONFIG.members["s3Uri"] - ) + kwargs["s3_uri"] = de.read_string(members[0]) case 1: - kwargs["kms_key_id"] = de.read_string( - _SCHEMA_ASYNC_INVOKE_S3_OUTPUT_DATA_CONFIG.members["kmsKeyId"] - ) + kwargs["kms_key_id"] = de.read_string(members[1]) case 2: - kwargs["bucket_owner"] = de.read_string( - _SCHEMA_ASYNC_INVOKE_S3_OUTPUT_DATA_CONFIG.members[ - "bucketOwner" - ] - ) + kwargs["bucket_owner"] = de.read_string(members[2]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_ASYNC_INVOKE_S3_OUTPUT_DATA_CONFIG, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) if "s3_uri" not in kwargs: kwargs["s3_uri"] = "" return kwargs @@ -422,13 +407,11 @@ class AsyncInvokeOutputDataConfigS3OutputDataConfig: value: AsyncInvokeS3OutputDataConfig def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_ASYNC_INVOKE_OUTPUT_DATA_CONFIG, self) + serializer.write_struct(hydrate(_SCHEMA_ASYNC_INVOKE_OUTPUT_DATA_CONFIG), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_struct( - _SCHEMA_ASYNC_INVOKE_OUTPUT_DATA_CONFIG.members["s3OutputDataConfig"], - self.value, - ) + members = hydrate(_SCHEMA_ASYNC_INVOKE_OUTPUT_DATA_CONFIG).members_by_index + serializer.write_struct(members[0], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -473,7 +456,7 @@ def deserialize( ) -> AsyncInvokeOutputDataConfig: self._result = None deserializer.read_struct( - _SCHEMA_ASYNC_INVOKE_OUTPUT_DATA_CONFIG, self._consumer + hydrate(_SCHEMA_ASYNC_INVOKE_OUTPUT_DATA_CONFIG), self._consumer ) if self._result is None: @@ -551,49 +534,27 @@ class GetAsyncInvokeOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_GET_ASYNC_INVOKE_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_GET_ASYNC_INVOKE_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_string( - _SCHEMA_GET_ASYNC_INVOKE_OUTPUT.members["invocationArn"], - self.invocation_arn, - ) - serializer.write_string( - _SCHEMA_GET_ASYNC_INVOKE_OUTPUT.members["modelArn"], self.model_arn - ) + members = hydrate(_SCHEMA_GET_ASYNC_INVOKE_OUTPUT).members_by_index + serializer.write_string(members[0], self.invocation_arn) + serializer.write_string(members[1], self.model_arn) if self.client_request_token is not None: - serializer.write_string( - _SCHEMA_GET_ASYNC_INVOKE_OUTPUT.members["clientRequestToken"], - self.client_request_token, - ) + serializer.write_string(members[2], self.client_request_token) - serializer.write_string( - _SCHEMA_GET_ASYNC_INVOKE_OUTPUT.members["status"], self.status - ) + serializer.write_string(members[3], self.status) if self.failure_message is not None: - serializer.write_string( - _SCHEMA_GET_ASYNC_INVOKE_OUTPUT.members["failureMessage"], - self.failure_message, - ) + serializer.write_string(members[4], self.failure_message) - serializer.write_timestamp( - _SCHEMA_GET_ASYNC_INVOKE_OUTPUT.members["submitTime"], self.submit_time - ) + serializer.write_timestamp(members[5], self.submit_time) if self.last_modified_time is not None: - serializer.write_timestamp( - _SCHEMA_GET_ASYNC_INVOKE_OUTPUT.members["lastModifiedTime"], - self.last_modified_time, - ) + serializer.write_timestamp(members[6], self.last_modified_time) if self.end_time is not None: - serializer.write_timestamp( - _SCHEMA_GET_ASYNC_INVOKE_OUTPUT.members["endTime"], self.end_time - ) + serializer.write_timestamp(members[7], self.end_time) - serializer.write_struct( - _SCHEMA_GET_ASYNC_INVOKE_OUTPUT.members["outputDataConfig"], - self.output_data_config, - ) + serializer.write_struct(members[8], self.output_data_config) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -602,50 +563,34 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_GET_ASYNC_INVOKE_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["invocation_arn"] = de.read_string( - _SCHEMA_GET_ASYNC_INVOKE_OUTPUT.members["invocationArn"] - ) + kwargs["invocation_arn"] = de.read_string(members[0]) case 1: - kwargs["model_arn"] = de.read_string( - _SCHEMA_GET_ASYNC_INVOKE_OUTPUT.members["modelArn"] - ) + kwargs["model_arn"] = de.read_string(members[1]) case 2: - kwargs["client_request_token"] = de.read_string( - _SCHEMA_GET_ASYNC_INVOKE_OUTPUT.members["clientRequestToken"] - ) + kwargs["client_request_token"] = de.read_string(members[2]) case 3: - kwargs["status"] = AsyncInvokeStatus( - de.read_string( - _SCHEMA_GET_ASYNC_INVOKE_OUTPUT.members["status"] - ) - ) + kwargs["status"] = AsyncInvokeStatus(de.read_string(members[3])) case 4: - kwargs["failure_message"] = de.read_string( - _SCHEMA_GET_ASYNC_INVOKE_OUTPUT.members["failureMessage"] - ) + kwargs["failure_message"] = de.read_string(members[4]) case 5: - kwargs["submit_time"] = de.read_timestamp( - _SCHEMA_GET_ASYNC_INVOKE_OUTPUT.members["submitTime"] - ) + kwargs["submit_time"] = de.read_timestamp(members[5]) case 6: - kwargs["last_modified_time"] = de.read_timestamp( - _SCHEMA_GET_ASYNC_INVOKE_OUTPUT.members["lastModifiedTime"] - ) + kwargs["last_modified_time"] = de.read_timestamp(members[6]) case 7: - kwargs["end_time"] = de.read_timestamp( - _SCHEMA_GET_ASYNC_INVOKE_OUTPUT.members["endTime"] - ) + kwargs["end_time"] = de.read_timestamp(members[7]) case 8: kwargs["output_data_config"] = ( @@ -653,9 +598,9 @@ def _consumer(schema: Schema, de: ShapeDeserializer) -> None: ) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_GET_ASYNC_INVOKE_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) if "invocation_arn" not in kwargs: kwargs["invocation_arn"] = "" if "model_arn" not in kwargs: @@ -680,13 +625,12 @@ class InternalServerException(ServiceError): fault: Literal["client", "server"] | None = "server" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_INTERNAL_SERVER_EXCEPTION, self) + serializer.write_struct(hydrate(_SCHEMA_INTERNAL_SERVER_EXCEPTION), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_INTERNAL_SERVER_EXCEPTION).members_by_index if self.message is not None: - serializer.write_string( - _SCHEMA_INTERNAL_SERVER_EXCEPTION.members["message"], self.message - ) + serializer.write_string(members[0], self.message) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -695,18 +639,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_INTERNAL_SERVER_EXCEPTION) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["message"] = de.read_string( - _SCHEMA_INTERNAL_SERVER_EXCEPTION.members["message"] - ) + kwargs["message"] = de.read_string(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_INTERNAL_SERVER_EXCEPTION, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -722,13 +666,12 @@ class ThrottlingException(ServiceError): fault: Literal["client", "server"] | None = "client" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_THROTTLING_EXCEPTION, self) + serializer.write_struct(hydrate(_SCHEMA_THROTTLING_EXCEPTION), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_THROTTLING_EXCEPTION).members_by_index if self.message is not None: - serializer.write_string( - _SCHEMA_THROTTLING_EXCEPTION.members["message"], self.message - ) + serializer.write_string(members[0], self.message) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -737,18 +680,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_THROTTLING_EXCEPTION) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["message"] = de.read_string( - _SCHEMA_THROTTLING_EXCEPTION.members["message"] - ) + kwargs["message"] = de.read_string(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_THROTTLING_EXCEPTION, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -764,13 +707,12 @@ class ValidationException(ServiceError): fault: Literal["client", "server"] | None = "client" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_VALIDATION_EXCEPTION, self) + serializer.write_struct(hydrate(_SCHEMA_VALIDATION_EXCEPTION), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_VALIDATION_EXCEPTION).members_by_index if self.message is not None: - serializer.write_string( - _SCHEMA_VALIDATION_EXCEPTION.members["message"], self.message - ) + serializer.write_string(members[0], self.message) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -779,27 +721,25 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_VALIDATION_EXCEPTION) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["message"] = de.read_string( - _SCHEMA_VALIDATION_EXCEPTION.members["message"] - ) + kwargs["message"] = de.read_string(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_VALIDATION_EXCEPTION, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs GET_ASYNC_INVOKE = APIOperation( input=GetAsyncInvokeInput, output=GetAsyncInvokeOutput, - schema=_SCHEMA_GET_ASYNC_INVOKE, - input_schema=_SCHEMA_GET_ASYNC_INVOKE_INPUT, - output_schema=_SCHEMA_GET_ASYNC_INVOKE_OUTPUT, + static_schema=_SCHEMA_GET_ASYNC_INVOKE, error_registry=TypeRegistry( { ShapeID( @@ -820,12 +760,6 @@ def _consumer(schema: Schema, de: ShapeDeserializer) -> None: ShapeID("aws.auth#sigv4"), ShapeID("smithy.api#httpBearerAuth"), ], - error_schemas=[ - _SCHEMA_ACCESS_DENIED_EXCEPTION, - _SCHEMA_INTERNAL_SERVER_EXCEPTION, - _SCHEMA_THROTTLING_EXCEPTION, - _SCHEMA_VALIDATION_EXCEPTION, - ], ) @@ -867,46 +801,30 @@ class ListAsyncInvokesInput: """The sorting order for the response.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_LIST_ASYNC_INVOKES_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_LIST_ASYNC_INVOKES_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_LIST_ASYNC_INVOKES_INPUT).members_by_index if self.submit_time_after is not None: - serializer.write_timestamp( - _SCHEMA_LIST_ASYNC_INVOKES_INPUT.members["submitTimeAfter"], - self.submit_time_after, - ) + serializer.write_timestamp(members[0], self.submit_time_after) if self.submit_time_before is not None: - serializer.write_timestamp( - _SCHEMA_LIST_ASYNC_INVOKES_INPUT.members["submitTimeBefore"], - self.submit_time_before, - ) + serializer.write_timestamp(members[1], self.submit_time_before) if self.status_equals is not None: - serializer.write_string( - _SCHEMA_LIST_ASYNC_INVOKES_INPUT.members["statusEquals"], - self.status_equals, - ) + serializer.write_string(members[2], self.status_equals) if self.max_results is not None: - serializer.write_integer( - _SCHEMA_LIST_ASYNC_INVOKES_INPUT.members["maxResults"], self.max_results - ) + serializer.write_integer(members[3], self.max_results) if self.next_token is not None: - serializer.write_string( - _SCHEMA_LIST_ASYNC_INVOKES_INPUT.members["nextToken"], self.next_token - ) + serializer.write_string(members[4], self.next_token) if self.sort_by is not None: - serializer.write_string( - _SCHEMA_LIST_ASYNC_INVOKES_INPUT.members["sortBy"], self.sort_by - ) + serializer.write_string(members[5], self.sort_by) if self.sort_order is not None: - serializer.write_string( - _SCHEMA_LIST_ASYNC_INVOKES_INPUT.members["sortOrder"], self.sort_order - ) + serializer.write_string(members[6], self.sort_order) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -915,54 +833,40 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_LIST_ASYNC_INVOKES_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["submit_time_after"] = de.read_timestamp( - _SCHEMA_LIST_ASYNC_INVOKES_INPUT.members["submitTimeAfter"] - ) + kwargs["submit_time_after"] = de.read_timestamp(members[0]) case 1: - kwargs["submit_time_before"] = de.read_timestamp( - _SCHEMA_LIST_ASYNC_INVOKES_INPUT.members["submitTimeBefore"] - ) + kwargs["submit_time_before"] = de.read_timestamp(members[1]) case 2: kwargs["status_equals"] = AsyncInvokeStatus( - de.read_string( - _SCHEMA_LIST_ASYNC_INVOKES_INPUT.members["statusEquals"] - ) + de.read_string(members[2]) ) case 3: - kwargs["max_results"] = de.read_integer( - _SCHEMA_LIST_ASYNC_INVOKES_INPUT.members["maxResults"] - ) + kwargs["max_results"] = de.read_integer(members[3]) case 4: - kwargs["next_token"] = de.read_string( - _SCHEMA_LIST_ASYNC_INVOKES_INPUT.members["nextToken"] - ) + kwargs["next_token"] = de.read_string(members[4]) case 5: kwargs["sort_by"] = SortAsyncInvocationBy( - de.read_string( - _SCHEMA_LIST_ASYNC_INVOKES_INPUT.members["sortBy"] - ) + de.read_string(members[5]) ) case 6: - kwargs["sort_order"] = SortOrder( - de.read_string( - _SCHEMA_LIST_ASYNC_INVOKES_INPUT.members["sortOrder"] - ) - ) + kwargs["sort_order"] = SortOrder(de.read_string(members[6])) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_LIST_ASYNC_INVOKES_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -998,50 +902,29 @@ class AsyncInvokeSummary: """When the invocation ended.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_ASYNC_INVOKE_SUMMARY, self) + serializer.write_struct(hydrate(_SCHEMA_ASYNC_INVOKE_SUMMARY), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_string( - _SCHEMA_ASYNC_INVOKE_SUMMARY.members["invocationArn"], self.invocation_arn - ) - serializer.write_string( - _SCHEMA_ASYNC_INVOKE_SUMMARY.members["modelArn"], self.model_arn - ) + members = hydrate(_SCHEMA_ASYNC_INVOKE_SUMMARY).members_by_index + serializer.write_string(members[0], self.invocation_arn) + serializer.write_string(members[1], self.model_arn) if self.client_request_token is not None: - serializer.write_string( - _SCHEMA_ASYNC_INVOKE_SUMMARY.members["clientRequestToken"], - self.client_request_token, - ) + serializer.write_string(members[2], self.client_request_token) if self.status is not None: - serializer.write_string( - _SCHEMA_ASYNC_INVOKE_SUMMARY.members["status"], self.status - ) + serializer.write_string(members[3], self.status) if self.failure_message is not None: - serializer.write_string( - _SCHEMA_ASYNC_INVOKE_SUMMARY.members["failureMessage"], - self.failure_message, - ) + serializer.write_string(members[4], self.failure_message) - serializer.write_timestamp( - _SCHEMA_ASYNC_INVOKE_SUMMARY.members["submitTime"], self.submit_time - ) + serializer.write_timestamp(members[5], self.submit_time) if self.last_modified_time is not None: - serializer.write_timestamp( - _SCHEMA_ASYNC_INVOKE_SUMMARY.members["lastModifiedTime"], - self.last_modified_time, - ) + serializer.write_timestamp(members[6], self.last_modified_time) if self.end_time is not None: - serializer.write_timestamp( - _SCHEMA_ASYNC_INVOKE_SUMMARY.members["endTime"], self.end_time - ) + serializer.write_timestamp(members[7], self.end_time) - serializer.write_struct( - _SCHEMA_ASYNC_INVOKE_SUMMARY.members["outputDataConfig"], - self.output_data_config, - ) + serializer.write_struct(members[8], self.output_data_config) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -1050,48 +933,34 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_ASYNC_INVOKE_SUMMARY) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["invocation_arn"] = de.read_string( - _SCHEMA_ASYNC_INVOKE_SUMMARY.members["invocationArn"] - ) + kwargs["invocation_arn"] = de.read_string(members[0]) case 1: - kwargs["model_arn"] = de.read_string( - _SCHEMA_ASYNC_INVOKE_SUMMARY.members["modelArn"] - ) + kwargs["model_arn"] = de.read_string(members[1]) case 2: - kwargs["client_request_token"] = de.read_string( - _SCHEMA_ASYNC_INVOKE_SUMMARY.members["clientRequestToken"] - ) + kwargs["client_request_token"] = de.read_string(members[2]) case 3: - kwargs["status"] = AsyncInvokeStatus( - de.read_string(_SCHEMA_ASYNC_INVOKE_SUMMARY.members["status"]) - ) + kwargs["status"] = AsyncInvokeStatus(de.read_string(members[3])) case 4: - kwargs["failure_message"] = de.read_string( - _SCHEMA_ASYNC_INVOKE_SUMMARY.members["failureMessage"] - ) + kwargs["failure_message"] = de.read_string(members[4]) case 5: - kwargs["submit_time"] = de.read_timestamp( - _SCHEMA_ASYNC_INVOKE_SUMMARY.members["submitTime"] - ) + kwargs["submit_time"] = de.read_timestamp(members[5]) case 6: - kwargs["last_modified_time"] = de.read_timestamp( - _SCHEMA_ASYNC_INVOKE_SUMMARY.members["lastModifiedTime"] - ) + kwargs["last_modified_time"] = de.read_timestamp(members[6]) case 7: - kwargs["end_time"] = de.read_timestamp( - _SCHEMA_ASYNC_INVOKE_SUMMARY.members["endTime"] - ) + kwargs["end_time"] = de.read_timestamp(members[7]) case 8: kwargs["output_data_config"] = ( @@ -1099,9 +968,9 @@ def _consumer(schema: Schema, de: ShapeDeserializer) -> None: ) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_ASYNC_INVOKE_SUMMARY, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) if "invocation_arn" not in kwargs: kwargs["invocation_arn"] = "" if "model_arn" not in kwargs: @@ -1116,7 +985,7 @@ def _consumer(schema: Schema, de: ShapeDeserializer) -> None: def _serialize_async_invoke_summaries( serializer: ShapeSerializer, schema: Schema, value: list[AsyncInvokeSummary] ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_struct(member_schema, e) @@ -1162,19 +1031,16 @@ class ListAsyncInvokesOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_LIST_ASYNC_INVOKES_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_LIST_ASYNC_INVOKES_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_LIST_ASYNC_INVOKES_OUTPUT).members_by_index if self.next_token is not None: - serializer.write_string( - _SCHEMA_LIST_ASYNC_INVOKES_OUTPUT.members["nextToken"], self.next_token - ) + serializer.write_string(members[0], self.next_token) if self.async_invoke_summaries is not None: _serialize_async_invoke_summaries( - serializer, - _SCHEMA_LIST_ASYNC_INVOKES_OUTPUT.members["asyncInvokeSummaries"], - self.async_invoke_summaries, + serializer, members[1], self.async_invoke_summaries ) @classmethod @@ -1184,37 +1050,30 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_LIST_ASYNC_INVOKES_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["next_token"] = de.read_string( - _SCHEMA_LIST_ASYNC_INVOKES_OUTPUT.members["nextToken"] - ) + kwargs["next_token"] = de.read_string(members[0]) case 1: kwargs["async_invoke_summaries"] = ( - _deserialize_async_invoke_summaries( - de, - _SCHEMA_LIST_ASYNC_INVOKES_OUTPUT.members[ - "asyncInvokeSummaries" - ], - ) + _deserialize_async_invoke_summaries(de, members[1]) ) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_LIST_ASYNC_INVOKES_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs LIST_ASYNC_INVOKES = APIOperation( input=ListAsyncInvokesInput, output=ListAsyncInvokesOutput, - schema=_SCHEMA_LIST_ASYNC_INVOKES, - input_schema=_SCHEMA_LIST_ASYNC_INVOKES_INPUT, - output_schema=_SCHEMA_LIST_ASYNC_INVOKES_OUTPUT, + static_schema=_SCHEMA_LIST_ASYNC_INVOKES, error_registry=TypeRegistry( { ShapeID( @@ -1235,12 +1094,6 @@ def _consumer(schema: Schema, de: ShapeDeserializer) -> None: ShapeID("aws.auth#sigv4"), ShapeID("smithy.api#httpBearerAuth"), ], - error_schemas=[ - _SCHEMA_ACCESS_DENIED_EXCEPTION, - _SCHEMA_INTERNAL_SERVER_EXCEPTION, - _SCHEMA_THROTTLING_EXCEPTION, - _SCHEMA_VALIDATION_EXCEPTION, - ], ) @@ -1251,13 +1104,12 @@ class ConflictException(ServiceError): fault: Literal["client", "server"] | None = "client" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_CONFLICT_EXCEPTION, self) + serializer.write_struct(hydrate(_SCHEMA_CONFLICT_EXCEPTION), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_CONFLICT_EXCEPTION).members_by_index if self.message is not None: - serializer.write_string( - _SCHEMA_CONFLICT_EXCEPTION.members["message"], self.message - ) + serializer.write_string(members[0], self.message) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -1266,18 +1118,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_CONFLICT_EXCEPTION) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["message"] = de.read_string( - _SCHEMA_CONFLICT_EXCEPTION.members["message"] - ) + kwargs["message"] = de.read_string(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_CONFLICT_EXCEPTION, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -1293,13 +1145,12 @@ class ResourceNotFoundException(ServiceError): fault: Literal["client", "server"] | None = "client" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_RESOURCE_NOT_FOUND_EXCEPTION, self) + serializer.write_struct(hydrate(_SCHEMA_RESOURCE_NOT_FOUND_EXCEPTION), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_RESOURCE_NOT_FOUND_EXCEPTION).members_by_index if self.message is not None: - serializer.write_string( - _SCHEMA_RESOURCE_NOT_FOUND_EXCEPTION.members["message"], self.message - ) + serializer.write_string(members[0], self.message) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -1308,20 +1159,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_RESOURCE_NOT_FOUND_EXCEPTION) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["message"] = de.read_string( - _SCHEMA_RESOURCE_NOT_FOUND_EXCEPTION.members["message"] - ) + kwargs["message"] = de.read_string(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_RESOURCE_NOT_FOUND_EXCEPTION, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -1337,14 +1186,12 @@ class ServiceQuotaExceededException(ServiceError): fault: Literal["client", "server"] | None = "client" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_SERVICE_QUOTA_EXCEEDED_EXCEPTION, self) + serializer.write_struct(hydrate(_SCHEMA_SERVICE_QUOTA_EXCEEDED_EXCEPTION), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_SERVICE_QUOTA_EXCEEDED_EXCEPTION).members_by_index if self.message is not None: - serializer.write_string( - _SCHEMA_SERVICE_QUOTA_EXCEEDED_EXCEPTION.members["message"], - self.message, - ) + serializer.write_string(members[0], self.message) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -1353,20 +1200,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_SERVICE_QUOTA_EXCEEDED_EXCEPTION) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["message"] = de.read_string( - _SCHEMA_SERVICE_QUOTA_EXCEEDED_EXCEPTION.members["message"] - ) + kwargs["message"] = de.read_string(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_SERVICE_QUOTA_EXCEEDED_EXCEPTION, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -1382,13 +1227,12 @@ class ServiceUnavailableException(ServiceError): fault: Literal["client", "server"] | None = "server" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_SERVICE_UNAVAILABLE_EXCEPTION, self) + serializer.write_struct(hydrate(_SCHEMA_SERVICE_UNAVAILABLE_EXCEPTION), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_SERVICE_UNAVAILABLE_EXCEPTION).members_by_index if self.message is not None: - serializer.write_string( - _SCHEMA_SERVICE_UNAVAILABLE_EXCEPTION.members["message"], self.message - ) + serializer.write_string(members[0], self.message) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -1397,20 +1241,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_SERVICE_UNAVAILABLE_EXCEPTION) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["message"] = de.read_string( - _SCHEMA_SERVICE_UNAVAILABLE_EXCEPTION.members["message"] - ) + kwargs["message"] = de.read_string(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_SERVICE_UNAVAILABLE_EXCEPTION, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -1425,11 +1267,12 @@ class Tag: """The tag's value.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_TAG, self) + serializer.write_struct(hydrate(_SCHEMA_TAG), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_string(_SCHEMA_TAG.members["key"], self.key) - serializer.write_string(_SCHEMA_TAG.members["value"], self.value) + members = hydrate(_SCHEMA_TAG).members_by_index + serializer.write_string(members[0], self.key) + serializer.write_string(members[1], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -1438,19 +1281,21 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_TAG) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["key"] = de.read_string(_SCHEMA_TAG.members["key"]) + kwargs["key"] = de.read_string(members[0]) case 1: - kwargs["value"] = de.read_string(_SCHEMA_TAG.members["value"]) + kwargs["value"] = de.read_string(members[1]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_TAG, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) if "key" not in kwargs: kwargs["key"] = "" if "value" not in kwargs: @@ -1461,7 +1306,7 @@ def _consumer(schema: Schema, de: ShapeDeserializer) -> None: def _serialize_tag_list( serializer: ShapeSerializer, schema: Schema, value: list[Tag] ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_struct(member_schema, e) @@ -1501,35 +1346,24 @@ class StartAsyncInvokeInput: """Tags to apply to the invocation.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_START_ASYNC_INVOKE_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_START_ASYNC_INVOKE_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_START_ASYNC_INVOKE_INPUT).members_by_index if self.client_request_token is not None: - serializer.write_string( - _SCHEMA_START_ASYNC_INVOKE_INPUT.members["clientRequestToken"], - self.client_request_token, - ) + serializer.write_string(members[0], self.client_request_token) if self.model_id is not None: - serializer.write_string( - _SCHEMA_START_ASYNC_INVOKE_INPUT.members["modelId"], self.model_id - ) + serializer.write_string(members[1], self.model_id) if self.model_input is not None: - serializer.write_document( - _SCHEMA_START_ASYNC_INVOKE_INPUT.members["modelInput"], self.model_input - ) + serializer.write_document(members[2], self.model_input) if self.output_data_config is not None: - serializer.write_struct( - _SCHEMA_START_ASYNC_INVOKE_INPUT.members["outputDataConfig"], - self.output_data_config, - ) + serializer.write_struct(members[3], self.output_data_config) if self.tags is not None: - _serialize_tag_list( - serializer, _SCHEMA_START_ASYNC_INVOKE_INPUT.members["tags"], self.tags - ) + _serialize_tag_list(serializer, members[4], self.tags) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -1538,23 +1372,19 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_START_ASYNC_INVOKE_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["client_request_token"] = de.read_string( - _SCHEMA_START_ASYNC_INVOKE_INPUT.members["clientRequestToken"] - ) + kwargs["client_request_token"] = de.read_string(members[0]) case 1: - kwargs["model_id"] = de.read_string( - _SCHEMA_START_ASYNC_INVOKE_INPUT.members["modelId"] - ) + kwargs["model_id"] = de.read_string(members[1]) case 2: - kwargs["model_input"] = de.read_document( - _SCHEMA_START_ASYNC_INVOKE_INPUT.members["modelInput"] - ) + kwargs["model_input"] = de.read_document(members[2]) case 3: kwargs["output_data_config"] = ( @@ -1562,14 +1392,12 @@ def _consumer(schema: Schema, de: ShapeDeserializer) -> None: ) case 4: - kwargs["tags"] = _deserialize_tag_list( - de, _SCHEMA_START_ASYNC_INVOKE_INPUT.members["tags"] - ) + kwargs["tags"] = _deserialize_tag_list(de, members[4]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_START_ASYNC_INVOKE_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -1591,13 +1419,11 @@ class StartAsyncInvokeOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_START_ASYNC_INVOKE_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_START_ASYNC_INVOKE_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_string( - _SCHEMA_START_ASYNC_INVOKE_OUTPUT.members["invocationArn"], - self.invocation_arn, - ) + members = hydrate(_SCHEMA_START_ASYNC_INVOKE_OUTPUT).members_by_index + serializer.write_string(members[0], self.invocation_arn) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -1606,18 +1432,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_START_ASYNC_INVOKE_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["invocation_arn"] = de.read_string( - _SCHEMA_START_ASYNC_INVOKE_OUTPUT.members["invocationArn"] - ) + kwargs["invocation_arn"] = de.read_string(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_START_ASYNC_INVOKE_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) if "invocation_arn" not in kwargs: kwargs["invocation_arn"] = "" return kwargs @@ -1626,9 +1452,7 @@ def _consumer(schema: Schema, de: ShapeDeserializer) -> None: START_ASYNC_INVOKE = APIOperation( input=StartAsyncInvokeInput, output=StartAsyncInvokeOutput, - schema=_SCHEMA_START_ASYNC_INVOKE, - input_schema=_SCHEMA_START_ASYNC_INVOKE_INPUT, - output_schema=_SCHEMA_START_ASYNC_INVOKE_OUTPUT, + static_schema=_SCHEMA_START_ASYNC_INVOKE, error_registry=TypeRegistry( { ShapeID( @@ -1661,16 +1485,6 @@ def _consumer(schema: Schema, de: ShapeDeserializer) -> None: ShapeID("aws.auth#sigv4"), ShapeID("smithy.api#httpBearerAuth"), ], - error_schemas=[ - _SCHEMA_ACCESS_DENIED_EXCEPTION, - _SCHEMA_CONFLICT_EXCEPTION, - _SCHEMA_INTERNAL_SERVER_EXCEPTION, - _SCHEMA_RESOURCE_NOT_FOUND_EXCEPTION, - _SCHEMA_SERVICE_QUOTA_EXCEEDED_EXCEPTION, - _SCHEMA_SERVICE_UNAVAILABLE_EXCEPTION, - _SCHEMA_THROTTLING_EXCEPTION, - _SCHEMA_VALIDATION_EXCEPTION, - ], ) @@ -1689,20 +1503,16 @@ class GuardrailImageSourceBytes: value: bytes def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_GUARDRAIL_IMAGE_SOURCE, self) + serializer.write_struct(hydrate(_SCHEMA_GUARDRAIL_IMAGE_SOURCE), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_blob( - _SCHEMA_GUARDRAIL_IMAGE_SOURCE.members["bytes"], self.value - ) + members = hydrate(_SCHEMA_GUARDRAIL_IMAGE_SOURCE).members_by_index + serializer.write_blob(members[0], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: - return cls( - value=deserializer.read_blob( - _SCHEMA_GUARDRAIL_IMAGE_SOURCE.members["bytes"] - ) - ) + members = hydrate(_SCHEMA_GUARDRAIL_IMAGE_SOURCE).members_by_index + return cls(value=deserializer.read_blob(members[0])) @dataclass @@ -1741,7 +1551,9 @@ class _GuardrailImageSourceDeserializer: def deserialize(self, deserializer: ShapeDeserializer) -> GuardrailImageSource: self._result = None - deserializer.read_struct(_SCHEMA_GUARDRAIL_IMAGE_SOURCE, self._consumer) + deserializer.read_struct( + hydrate(_SCHEMA_GUARDRAIL_IMAGE_SOURCE), self._consumer + ) if self._result is None: raise SerializationError( @@ -1788,15 +1600,12 @@ class GuardrailImageBlock: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_GUARDRAIL_IMAGE_BLOCK, self) + serializer.write_struct(hydrate(_SCHEMA_GUARDRAIL_IMAGE_BLOCK), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_string( - _SCHEMA_GUARDRAIL_IMAGE_BLOCK.members["format"], self.format - ) - serializer.write_struct( - _SCHEMA_GUARDRAIL_IMAGE_BLOCK.members["source"], self.source - ) + members = hydrate(_SCHEMA_GUARDRAIL_IMAGE_BLOCK).members_by_index + serializer.write_string(members[0], self.format) + serializer.write_struct(members[1], self.source) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -1805,13 +1614,13 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_GUARDRAIL_IMAGE_BLOCK) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["format"] = GuardrailImageFormat( - de.read_string(_SCHEMA_GUARDRAIL_IMAGE_BLOCK.members["format"]) - ) + kwargs["format"] = GuardrailImageFormat(de.read_string(members[0])) case 1: kwargs["source"] = _GuardrailImageSourceDeserializer().deserialize( @@ -1819,9 +1628,9 @@ def _consumer(schema: Schema, de: ShapeDeserializer) -> None: ) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_GUARDRAIL_IMAGE_BLOCK, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) if "format" not in kwargs: kwargs["format"] = GuardrailImageFormat._corrected("") if "source" not in kwargs: @@ -1838,7 +1647,7 @@ class GuardrailContentQualifier(UnknownEnumMixin, StrEnum): def _serialize_guardrail_content_qualifier_list( serializer: ShapeSerializer, schema: Schema, value: list[str] ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_string(member_schema, e) @@ -1848,7 +1657,7 @@ def _deserialize_guardrail_content_qualifier_list( deserializer: ShapeDeserializer, schema: Schema ) -> list[str]: result: list[str] = [] - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] def _read_value(d: ShapeDeserializer): if d.is_null(): @@ -1872,15 +1681,14 @@ class GuardrailTextBlock: """The qualifiers describing the text block.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_GUARDRAIL_TEXT_BLOCK, self) + serializer.write_struct(hydrate(_SCHEMA_GUARDRAIL_TEXT_BLOCK), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_string(_SCHEMA_GUARDRAIL_TEXT_BLOCK.members["text"], self.text) + members = hydrate(_SCHEMA_GUARDRAIL_TEXT_BLOCK).members_by_index + serializer.write_string(members[0], self.text) if self.qualifiers is not None: _serialize_guardrail_content_qualifier_list( - serializer, - _SCHEMA_GUARDRAIL_TEXT_BLOCK.members["qualifiers"], - self.qualifiers, + serializer, members[1], self.qualifiers ) @classmethod @@ -1890,25 +1698,23 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_GUARDRAIL_TEXT_BLOCK) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["text"] = de.read_string( - _SCHEMA_GUARDRAIL_TEXT_BLOCK.members["text"] - ) + kwargs["text"] = de.read_string(members[0]) case 1: kwargs["qualifiers"] = ( - _deserialize_guardrail_content_qualifier_list( - de, _SCHEMA_GUARDRAIL_TEXT_BLOCK.members["qualifiers"] - ) + _deserialize_guardrail_content_qualifier_list(de, members[1]) ) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_GUARDRAIL_TEXT_BLOCK, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) if "text" not in kwargs: kwargs["text"] = "" return kwargs @@ -1921,12 +1727,11 @@ class GuardrailContentBlockText: value: GuardrailTextBlock def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_GUARDRAIL_CONTENT_BLOCK, self) + serializer.write_struct(hydrate(_SCHEMA_GUARDRAIL_CONTENT_BLOCK), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_struct( - _SCHEMA_GUARDRAIL_CONTENT_BLOCK.members["text"], self.value - ) + members = hydrate(_SCHEMA_GUARDRAIL_CONTENT_BLOCK).members_by_index + serializer.write_struct(members[0], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -1940,12 +1745,11 @@ class GuardrailContentBlockImage: value: GuardrailImageBlock def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_GUARDRAIL_CONTENT_BLOCK, self) + serializer.write_struct(hydrate(_SCHEMA_GUARDRAIL_CONTENT_BLOCK), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_struct( - _SCHEMA_GUARDRAIL_CONTENT_BLOCK.members["image"], self.value - ) + members = hydrate(_SCHEMA_GUARDRAIL_CONTENT_BLOCK).members_by_index + serializer.write_struct(members[1], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -1989,7 +1793,9 @@ class _GuardrailContentBlockDeserializer: def deserialize(self, deserializer: ShapeDeserializer) -> GuardrailContentBlock: self._result = None - deserializer.read_struct(_SCHEMA_GUARDRAIL_CONTENT_BLOCK, self._consumer) + deserializer.read_struct( + hydrate(_SCHEMA_GUARDRAIL_CONTENT_BLOCK), self._consumer + ) if self._result is None: raise SerializationError( @@ -2022,7 +1828,7 @@ def _set_result(self, value: GuardrailContentBlock) -> None: def _serialize_guardrail_content_block_list( serializer: ShapeSerializer, schema: Schema, value: list[GuardrailContentBlock] ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_struct(member_schema, e) @@ -2083,37 +1889,26 @@ class ApplyGuardrailInput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_APPLY_GUARDRAIL_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_APPLY_GUARDRAIL_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_APPLY_GUARDRAIL_INPUT).members_by_index if self.guardrail_identifier is not None: - serializer.write_string( - _SCHEMA_APPLY_GUARDRAIL_INPUT.members["guardrailIdentifier"], - self.guardrail_identifier, - ) + serializer.write_string(members[0], self.guardrail_identifier) if self.guardrail_version is not None: - serializer.write_string( - _SCHEMA_APPLY_GUARDRAIL_INPUT.members["guardrailVersion"], - self.guardrail_version, - ) + serializer.write_string(members[1], self.guardrail_version) if self.source is not None: - serializer.write_string( - _SCHEMA_APPLY_GUARDRAIL_INPUT.members["source"], self.source - ) + serializer.write_string(members[2], self.source) if self.content is not None: _serialize_guardrail_content_block_list( - serializer, - _SCHEMA_APPLY_GUARDRAIL_INPUT.members["content"], - self.content, + serializer, members[3], self.content ) if self.output_scope is not None: - serializer.write_string( - _SCHEMA_APPLY_GUARDRAIL_INPUT.members["outputScope"], self.output_scope - ) + serializer.write_string(members[4], self.output_scope) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -2122,40 +1917,36 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_APPLY_GUARDRAIL_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["guardrail_identifier"] = de.read_string( - _SCHEMA_APPLY_GUARDRAIL_INPUT.members["guardrailIdentifier"] - ) + kwargs["guardrail_identifier"] = de.read_string(members[0]) case 1: - kwargs["guardrail_version"] = de.read_string( - _SCHEMA_APPLY_GUARDRAIL_INPUT.members["guardrailVersion"] - ) + kwargs["guardrail_version"] = de.read_string(members[1]) case 2: kwargs["source"] = GuardrailContentSource( - de.read_string(_SCHEMA_APPLY_GUARDRAIL_INPUT.members["source"]) + de.read_string(members[2]) ) case 3: kwargs["content"] = _deserialize_guardrail_content_block_list( - de, _SCHEMA_APPLY_GUARDRAIL_INPUT.members["content"] + de, members[3] ) case 4: kwargs["output_scope"] = GuardrailOutputScope( - de.read_string( - _SCHEMA_APPLY_GUARDRAIL_INPUT.members["outputScope"] - ) + de.read_string(members[4]) ) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_APPLY_GUARDRAIL_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -2173,7 +1964,7 @@ class GuardrailOrigin(UnknownEnumMixin, StrEnum): def _serialize_guardrail_origin_list( serializer: ShapeSerializer, schema: Schema, value: list[str] ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_string(member_schema, e) @@ -2183,7 +1974,7 @@ def _deserialize_guardrail_origin_list( deserializer: ShapeDeserializer, schema: Schema ) -> list[str]: result: list[str] = [] - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] def _read_value(d: ShapeDeserializer): if d.is_null(): @@ -2233,39 +2024,26 @@ class AppliedGuardrailDetails: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_APPLIED_GUARDRAIL_DETAILS, self) + serializer.write_struct(hydrate(_SCHEMA_APPLIED_GUARDRAIL_DETAILS), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_APPLIED_GUARDRAIL_DETAILS).members_by_index if self.guardrail_id is not None: - serializer.write_string( - _SCHEMA_APPLIED_GUARDRAIL_DETAILS.members["guardrailId"], - self.guardrail_id, - ) + serializer.write_string(members[0], self.guardrail_id) if self.guardrail_version is not None: - serializer.write_string( - _SCHEMA_APPLIED_GUARDRAIL_DETAILS.members["guardrailVersion"], - self.guardrail_version, - ) + serializer.write_string(members[1], self.guardrail_version) if self.guardrail_arn is not None: - serializer.write_string( - _SCHEMA_APPLIED_GUARDRAIL_DETAILS.members["guardrailArn"], - self.guardrail_arn, - ) + serializer.write_string(members[2], self.guardrail_arn) if self.guardrail_origin is not None: _serialize_guardrail_origin_list( - serializer, - _SCHEMA_APPLIED_GUARDRAIL_DETAILS.members["guardrailOrigin"], - self.guardrail_origin, + serializer, members[3], self.guardrail_origin ) if self.guardrail_ownership is not None: - serializer.write_string( - _SCHEMA_APPLIED_GUARDRAIL_DETAILS.members["guardrailOwnership"], - self.guardrail_ownership, - ) + serializer.write_string(members[4], self.guardrail_ownership) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -2274,42 +2052,34 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_APPLIED_GUARDRAIL_DETAILS) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["guardrail_id"] = de.read_string( - _SCHEMA_APPLIED_GUARDRAIL_DETAILS.members["guardrailId"] - ) + kwargs["guardrail_id"] = de.read_string(members[0]) case 1: - kwargs["guardrail_version"] = de.read_string( - _SCHEMA_APPLIED_GUARDRAIL_DETAILS.members["guardrailVersion"] - ) + kwargs["guardrail_version"] = de.read_string(members[1]) case 2: - kwargs["guardrail_arn"] = de.read_string( - _SCHEMA_APPLIED_GUARDRAIL_DETAILS.members["guardrailArn"] - ) + kwargs["guardrail_arn"] = de.read_string(members[2]) case 3: kwargs["guardrail_origin"] = _deserialize_guardrail_origin_list( - de, _SCHEMA_APPLIED_GUARDRAIL_DETAILS.members["guardrailOrigin"] + de, members[3] ) case 4: kwargs["guardrail_ownership"] = GuardrailOwnership( - de.read_string( - _SCHEMA_APPLIED_GUARDRAIL_DETAILS.members[ - "guardrailOwnership" - ] - ) + de.read_string(members[4]) ) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_APPLIED_GUARDRAIL_DETAILS, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -2330,20 +2100,17 @@ class GuardrailAutomatedReasoningRule: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_GUARDRAIL_AUTOMATED_REASONING_RULE, self) + serializer.write_struct( + hydrate(_SCHEMA_GUARDRAIL_AUTOMATED_REASONING_RULE), self + ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_GUARDRAIL_AUTOMATED_REASONING_RULE).members_by_index if self.identifier is not None: - serializer.write_string( - _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_RULE.members["identifier"], - self.identifier, - ) + serializer.write_string(members[0], self.identifier) if self.policy_version_arn is not None: - serializer.write_string( - _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_RULE.members["policyVersionArn"], - self.policy_version_arn, - ) + serializer.write_string(members[1], self.policy_version_arn) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -2352,27 +2119,21 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_GUARDRAIL_AUTOMATED_REASONING_RULE) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["identifier"] = de.read_string( - _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_RULE.members["identifier"] - ) + kwargs["identifier"] = de.read_string(members[0]) case 1: - kwargs["policy_version_arn"] = de.read_string( - _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_RULE.members[ - "policyVersionArn" - ] - ) + kwargs["policy_version_arn"] = de.read_string(members[1]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_RULE, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -2381,7 +2142,7 @@ def _serialize_guardrail_automated_reasoning_rule_list( schema: Schema, value: list[GuardrailAutomatedReasoningRule], ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_struct(member_schema, e) @@ -2417,22 +2178,19 @@ class GuardrailAutomatedReasoningStatement: """The natural language explanation of the logical statement.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_GUARDRAIL_AUTOMATED_REASONING_STATEMENT, self) + serializer.write_struct( + hydrate(_SCHEMA_GUARDRAIL_AUTOMATED_REASONING_STATEMENT), self + ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate( + _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_STATEMENT + ).members_by_index if self.logic is not None: - serializer.write_string( - _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_STATEMENT.members["logic"], - self.logic, - ) + serializer.write_string(members[0], self.logic) if self.natural_language is not None: - serializer.write_string( - _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_STATEMENT.members[ - "naturalLanguage" - ], - self.natural_language, - ) + serializer.write_string(members[1], self.natural_language) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -2441,27 +2199,21 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_GUARDRAIL_AUTOMATED_REASONING_STATEMENT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["logic"] = de.read_string( - _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_STATEMENT.members["logic"] - ) + kwargs["logic"] = de.read_string(members[0]) case 1: - kwargs["natural_language"] = de.read_string( - _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_STATEMENT.members[ - "naturalLanguage" - ] - ) + kwargs["natural_language"] = de.read_string(members[1]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_STATEMENT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -2470,7 +2222,7 @@ def _serialize_guardrail_automated_reasoning_statement_list( schema: Schema, value: list[GuardrailAutomatedReasoningStatement], ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_struct(member_schema, e) @@ -2525,28 +2277,24 @@ class GuardrailAutomatedReasoningLogicWarning: def serialize(self, serializer: ShapeSerializer): serializer.write_struct( - _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_LOGIC_WARNING, self + hydrate(_SCHEMA_GUARDRAIL_AUTOMATED_REASONING_LOGIC_WARNING), self ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate( + _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_LOGIC_WARNING + ).members_by_index if self.type is not None: - serializer.write_string( - _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_LOGIC_WARNING.members["type"], - self.type, - ) + serializer.write_string(members[0], self.type) if self.premises is not None: _serialize_guardrail_automated_reasoning_statement_list( - serializer, - _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_LOGIC_WARNING.members["premises"], - self.premises, + serializer, members[1], self.premises ) if self.claims is not None: _serialize_guardrail_automated_reasoning_statement_list( - serializer, - _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_LOGIC_WARNING.members["claims"], - self.claims, + serializer, members[2], self.claims ) @classmethod @@ -2556,44 +2304,34 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_GUARDRAIL_AUTOMATED_REASONING_LOGIC_WARNING) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["type"] = GuardrailAutomatedReasoningLogicWarningType( - de.read_string( - _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_LOGIC_WARNING.members[ - "type" - ] - ) + de.read_string(members[0]) ) case 1: kwargs["premises"] = ( _deserialize_guardrail_automated_reasoning_statement_list( - de, - _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_LOGIC_WARNING.members[ - "premises" - ], + de, members[1] ) ) case 2: kwargs["claims"] = ( _deserialize_guardrail_automated_reasoning_statement_list( - de, - _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_LOGIC_WARNING.members[ - "claims" - ], + de, members[2] ) ) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_LOGIC_WARNING, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -2609,17 +2347,15 @@ class GuardrailAutomatedReasoningInputTextReference: def serialize(self, serializer: ShapeSerializer): serializer.write_struct( - _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_INPUT_TEXT_REFERENCE, self + hydrate(_SCHEMA_GUARDRAIL_AUTOMATED_REASONING_INPUT_TEXT_REFERENCE), self ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate( + _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_INPUT_TEXT_REFERENCE + ).members_by_index if self.text is not None: - serializer.write_string( - _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_INPUT_TEXT_REFERENCE.members[ - "text" - ], - self.text, - ) + serializer.write_string(members[0], self.text) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -2628,23 +2364,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_GUARDRAIL_AUTOMATED_REASONING_INPUT_TEXT_REFERENCE) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["text"] = de.read_string( - _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_INPUT_TEXT_REFERENCE.members[ - "text" - ] - ) + kwargs["text"] = de.read_string(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_INPUT_TEXT_REFERENCE, - consumer=_consumer, - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -2653,7 +2384,7 @@ def _serialize_guardrail_automated_reasoning_input_text_reference_list( schema: Schema, value: list[GuardrailAutomatedReasoningInputTextReference], ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_struct(member_schema, e) @@ -2717,46 +2448,36 @@ class GuardrailAutomatedReasoningTranslation: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_GUARDRAIL_AUTOMATED_REASONING_TRANSLATION, self) + serializer.write_struct( + hydrate(_SCHEMA_GUARDRAIL_AUTOMATED_REASONING_TRANSLATION), self + ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate( + _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_TRANSLATION + ).members_by_index if self.premises is not None: _serialize_guardrail_automated_reasoning_statement_list( - serializer, - _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_TRANSLATION.members["premises"], - self.premises, + serializer, members[0], self.premises ) if self.claims is not None: _serialize_guardrail_automated_reasoning_statement_list( - serializer, - _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_TRANSLATION.members["claims"], - self.claims, + serializer, members[1], self.claims ) if self.untranslated_premises is not None: _serialize_guardrail_automated_reasoning_input_text_reference_list( - serializer, - _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_TRANSLATION.members[ - "untranslatedPremises" - ], - self.untranslated_premises, + serializer, members[2], self.untranslated_premises ) if self.untranslated_claims is not None: _serialize_guardrail_automated_reasoning_input_text_reference_list( - serializer, - _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_TRANSLATION.members[ - "untranslatedClaims" - ], - self.untranslated_claims, + serializer, members[3], self.untranslated_claims ) if self.confidence is not None: - serializer.write_double( - _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_TRANSLATION.members["confidence"], - self.confidence, - ) + serializer.write_double(members[4], self.confidence) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -2765,62 +2486,46 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_GUARDRAIL_AUTOMATED_REASONING_TRANSLATION) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["premises"] = ( _deserialize_guardrail_automated_reasoning_statement_list( - de, - _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_TRANSLATION.members[ - "premises" - ], + de, members[0] ) ) case 1: kwargs["claims"] = ( _deserialize_guardrail_automated_reasoning_statement_list( - de, - _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_TRANSLATION.members[ - "claims" - ], + de, members[1] ) ) case 2: kwargs["untranslated_premises"] = ( _deserialize_guardrail_automated_reasoning_input_text_reference_list( - de, - _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_TRANSLATION.members[ - "untranslatedPremises" - ], + de, members[2] ) ) case 3: kwargs["untranslated_claims"] = ( _deserialize_guardrail_automated_reasoning_input_text_reference_list( - de, - _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_TRANSLATION.members[ - "untranslatedClaims" - ], + de, members[3] ) ) case 4: - kwargs["confidence"] = de.read_double( - _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_TRANSLATION.members[ - "confidence" - ] - ) + kwargs["confidence"] = de.read_double(members[4]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_TRANSLATION, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -2848,34 +2553,23 @@ class GuardrailAutomatedReasoningImpossibleFinding: def serialize(self, serializer: ShapeSerializer): serializer.write_struct( - _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_IMPOSSIBLE_FINDING, self + hydrate(_SCHEMA_GUARDRAIL_AUTOMATED_REASONING_IMPOSSIBLE_FINDING), self ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate( + _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_IMPOSSIBLE_FINDING + ).members_by_index if self.translation is not None: - serializer.write_struct( - _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_IMPOSSIBLE_FINDING.members[ - "translation" - ], - self.translation, - ) + serializer.write_struct(members[0], self.translation) if self.contradicting_rules is not None: _serialize_guardrail_automated_reasoning_rule_list( - serializer, - _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_IMPOSSIBLE_FINDING.members[ - "contradictingRules" - ], - self.contradicting_rules, + serializer, members[1], self.contradicting_rules ) if self.logic_warning is not None: - serializer.write_struct( - _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_IMPOSSIBLE_FINDING.members[ - "logicWarning" - ], - self.logic_warning, - ) + serializer.write_struct(members[2], self.logic_warning) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -2884,9 +2578,11 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_GUARDRAIL_AUTOMATED_REASONING_IMPOSSIBLE_FINDING) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["translation"] = ( GuardrailAutomatedReasoningTranslation.deserialize(de) @@ -2895,10 +2591,7 @@ def _consumer(schema: Schema, de: ShapeDeserializer) -> None: case 1: kwargs["contradicting_rules"] = ( _deserialize_guardrail_automated_reasoning_rule_list( - de, - _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_IMPOSSIBLE_FINDING.members[ - "contradictingRules" - ], + de, members[1] ) ) @@ -2908,11 +2601,9 @@ def _consumer(schema: Schema, de: ShapeDeserializer) -> None: ) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_IMPOSSIBLE_FINDING, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -2940,34 +2631,23 @@ class GuardrailAutomatedReasoningInvalidFinding: def serialize(self, serializer: ShapeSerializer): serializer.write_struct( - _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_INVALID_FINDING, self + hydrate(_SCHEMA_GUARDRAIL_AUTOMATED_REASONING_INVALID_FINDING), self ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate( + _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_INVALID_FINDING + ).members_by_index if self.translation is not None: - serializer.write_struct( - _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_INVALID_FINDING.members[ - "translation" - ], - self.translation, - ) + serializer.write_struct(members[0], self.translation) if self.contradicting_rules is not None: _serialize_guardrail_automated_reasoning_rule_list( - serializer, - _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_INVALID_FINDING.members[ - "contradictingRules" - ], - self.contradicting_rules, + serializer, members[1], self.contradicting_rules ) if self.logic_warning is not None: - serializer.write_struct( - _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_INVALID_FINDING.members[ - "logicWarning" - ], - self.logic_warning, - ) + serializer.write_struct(members[2], self.logic_warning) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -2976,9 +2656,11 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_GUARDRAIL_AUTOMATED_REASONING_INVALID_FINDING) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["translation"] = ( GuardrailAutomatedReasoningTranslation.deserialize(de) @@ -2987,10 +2669,7 @@ def _consumer(schema: Schema, de: ShapeDeserializer) -> None: case 1: kwargs["contradicting_rules"] = ( _deserialize_guardrail_automated_reasoning_rule_list( - de, - _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_INVALID_FINDING.members[ - "contradictingRules" - ], + de, members[1] ) ) @@ -3000,11 +2679,9 @@ def _consumer(schema: Schema, de: ShapeDeserializer) -> None: ) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_INVALID_FINDING, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -3017,7 +2694,7 @@ class GuardrailAutomatedReasoningNoTranslationsFinding: def serialize(self, serializer: ShapeSerializer): serializer.write_struct( - _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_NO_TRANSLATIONS_FINDING, self + hydrate(_SCHEMA_GUARDRAIL_AUTOMATED_REASONING_NO_TRANSLATIONS_FINDING), self ) def serialize_members(self, serializer: ShapeSerializer): @@ -3030,16 +2707,14 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_GUARDRAIL_AUTOMATED_REASONING_NO_TRANSLATIONS_FINDING) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_NO_TRANSLATIONS_FINDING, - consumer=_consumer, - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -3054,14 +2729,17 @@ class GuardrailAutomatedReasoningScenario: """List of logical assignments and statements that define this scenario.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_GUARDRAIL_AUTOMATED_REASONING_SCENARIO, self) + serializer.write_struct( + hydrate(_SCHEMA_GUARDRAIL_AUTOMATED_REASONING_SCENARIO), self + ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate( + _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_SCENARIO + ).members_by_index if self.statements is not None: _serialize_guardrail_automated_reasoning_statement_list( - serializer, - _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_SCENARIO.members["statements"], - self.statements, + serializer, members[0], self.statements ) @classmethod @@ -3071,25 +2749,22 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_GUARDRAIL_AUTOMATED_REASONING_SCENARIO) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["statements"] = ( _deserialize_guardrail_automated_reasoning_statement_list( - de, - _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_SCENARIO.members[ - "statements" - ], + de, members[0] ) ) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_SCENARIO, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -3123,41 +2798,24 @@ class GuardrailAutomatedReasoningSatisfiableFinding: def serialize(self, serializer: ShapeSerializer): serializer.write_struct( - _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_SATISFIABLE_FINDING, self + hydrate(_SCHEMA_GUARDRAIL_AUTOMATED_REASONING_SATISFIABLE_FINDING), self ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate( + _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_SATISFIABLE_FINDING + ).members_by_index if self.translation is not None: - serializer.write_struct( - _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_SATISFIABLE_FINDING.members[ - "translation" - ], - self.translation, - ) + serializer.write_struct(members[0], self.translation) if self.claims_true_scenario is not None: - serializer.write_struct( - _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_SATISFIABLE_FINDING.members[ - "claimsTrueScenario" - ], - self.claims_true_scenario, - ) + serializer.write_struct(members[1], self.claims_true_scenario) if self.claims_false_scenario is not None: - serializer.write_struct( - _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_SATISFIABLE_FINDING.members[ - "claimsFalseScenario" - ], - self.claims_false_scenario, - ) + serializer.write_struct(members[2], self.claims_false_scenario) if self.logic_warning is not None: - serializer.write_struct( - _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_SATISFIABLE_FINDING.members[ - "logicWarning" - ], - self.logic_warning, - ) + serializer.write_struct(members[3], self.logic_warning) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -3166,9 +2824,11 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_GUARDRAIL_AUTOMATED_REASONING_SATISFIABLE_FINDING) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["translation"] = ( GuardrailAutomatedReasoningTranslation.deserialize(de) @@ -3190,12 +2850,9 @@ def _consumer(schema: Schema, de: ShapeDeserializer) -> None: ) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_SATISFIABLE_FINDING, - consumer=_consumer, - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -3208,7 +2865,7 @@ class GuardrailAutomatedReasoningTooComplexFinding: def serialize(self, serializer: ShapeSerializer): serializer.write_struct( - _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_TOO_COMPLEX_FINDING, self + hydrate(_SCHEMA_GUARDRAIL_AUTOMATED_REASONING_TOO_COMPLEX_FINDING), self ) def serialize_members(self, serializer: ShapeSerializer): @@ -3221,16 +2878,14 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_GUARDRAIL_AUTOMATED_REASONING_TOO_COMPLEX_FINDING) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_TOO_COMPLEX_FINDING, - consumer=_consumer, - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -3239,7 +2894,7 @@ def _serialize_guardrail_automated_reasoning_difference_scenario_list( schema: Schema, value: list[GuardrailAutomatedReasoningScenario], ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_struct(member_schema, e) @@ -3266,7 +2921,7 @@ def _serialize_guardrail_automated_reasoning_translation_list( schema: Schema, value: list[GuardrailAutomatedReasoningTranslation], ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_struct(member_schema, e) @@ -3303,17 +2958,16 @@ class GuardrailAutomatedReasoningTranslationOption: def serialize(self, serializer: ShapeSerializer): serializer.write_struct( - _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_TRANSLATION_OPTION, self + hydrate(_SCHEMA_GUARDRAIL_AUTOMATED_REASONING_TRANSLATION_OPTION), self ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate( + _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_TRANSLATION_OPTION + ).members_by_index if self.translations is not None: _serialize_guardrail_automated_reasoning_translation_list( - serializer, - _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_TRANSLATION_OPTION.members[ - "translations" - ], - self.translations, + serializer, members[0], self.translations ) @classmethod @@ -3323,25 +2977,22 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_GUARDRAIL_AUTOMATED_REASONING_TRANSLATION_OPTION) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["translations"] = ( _deserialize_guardrail_automated_reasoning_translation_list( - de, - _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_TRANSLATION_OPTION.members[ - "translations" - ], + de, members[0] ) ) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_TRANSLATION_OPTION, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -3350,7 +3001,7 @@ def _serialize_guardrail_automated_reasoning_translation_option_list( schema: Schema, value: list[GuardrailAutomatedReasoningTranslationOption], ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_struct(member_schema, e) @@ -3393,26 +3044,24 @@ class GuardrailAutomatedReasoningTranslationAmbiguousFinding: def serialize(self, serializer: ShapeSerializer): serializer.write_struct( - _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_TRANSLATION_AMBIGUOUS_FINDING, self + hydrate( + _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_TRANSLATION_AMBIGUOUS_FINDING + ), + self, ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate( + _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_TRANSLATION_AMBIGUOUS_FINDING + ).members_by_index if self.options is not None: _serialize_guardrail_automated_reasoning_translation_option_list( - serializer, - _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_TRANSLATION_AMBIGUOUS_FINDING.members[ - "options" - ], - self.options, + serializer, members[0], self.options ) if self.difference_scenarios is not None: _serialize_guardrail_automated_reasoning_difference_scenario_list( - serializer, - _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_TRANSLATION_AMBIGUOUS_FINDING.members[ - "differenceScenarios" - ], - self.difference_scenarios, + serializer, members[1], self.difference_scenarios ) @classmethod @@ -3422,36 +3071,31 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate( + _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_TRANSLATION_AMBIGUOUS_FINDING + ) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["options"] = ( _deserialize_guardrail_automated_reasoning_translation_option_list( - de, - _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_TRANSLATION_AMBIGUOUS_FINDING.members[ - "options" - ], + de, members[0] ) ) case 1: kwargs["difference_scenarios"] = ( _deserialize_guardrail_automated_reasoning_difference_scenario_list( - de, - _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_TRANSLATION_AMBIGUOUS_FINDING.members[ - "differenceScenarios" - ], + de, members[1] ) ) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_TRANSLATION_AMBIGUOUS_FINDING, - consumer=_consumer, - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -3482,42 +3126,26 @@ class GuardrailAutomatedReasoningValidFinding: def serialize(self, serializer: ShapeSerializer): serializer.write_struct( - _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_VALID_FINDING, self + hydrate(_SCHEMA_GUARDRAIL_AUTOMATED_REASONING_VALID_FINDING), self ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate( + _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_VALID_FINDING + ).members_by_index if self.translation is not None: - serializer.write_struct( - _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_VALID_FINDING.members[ - "translation" - ], - self.translation, - ) + serializer.write_struct(members[0], self.translation) if self.claims_true_scenario is not None: - serializer.write_struct( - _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_VALID_FINDING.members[ - "claimsTrueScenario" - ], - self.claims_true_scenario, - ) + serializer.write_struct(members[1], self.claims_true_scenario) if self.supporting_rules is not None: _serialize_guardrail_automated_reasoning_rule_list( - serializer, - _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_VALID_FINDING.members[ - "supportingRules" - ], - self.supporting_rules, + serializer, members[2], self.supporting_rules ) if self.logic_warning is not None: - serializer.write_struct( - _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_VALID_FINDING.members[ - "logicWarning" - ], - self.logic_warning, - ) + serializer.write_struct(members[3], self.logic_warning) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -3526,9 +3154,11 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_GUARDRAIL_AUTOMATED_REASONING_VALID_FINDING) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["translation"] = ( GuardrailAutomatedReasoningTranslation.deserialize(de) @@ -3542,10 +3172,7 @@ def _consumer(schema: Schema, de: ShapeDeserializer) -> None: case 2: kwargs["supporting_rules"] = ( _deserialize_guardrail_automated_reasoning_rule_list( - de, - _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_VALID_FINDING.members[ - "supportingRules" - ], + de, members[2] ) ) @@ -3555,11 +3182,9 @@ def _consumer(schema: Schema, de: ShapeDeserializer) -> None: ) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_VALID_FINDING, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -3574,13 +3199,16 @@ class GuardrailAutomatedReasoningFindingValid: value: GuardrailAutomatedReasoningValidFinding def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_GUARDRAIL_AUTOMATED_REASONING_FINDING, self) - - def serialize_members(self, serializer: ShapeSerializer): serializer.write_struct( - _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_FINDING.members["valid"], self.value + hydrate(_SCHEMA_GUARDRAIL_AUTOMATED_REASONING_FINDING), self ) + def serialize_members(self, serializer: ShapeSerializer): + members = hydrate( + _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_FINDING + ).members_by_index + serializer.write_struct(members[0], self.value) + @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: return cls( @@ -3599,13 +3227,16 @@ class GuardrailAutomatedReasoningFindingInvalid: value: GuardrailAutomatedReasoningInvalidFinding def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_GUARDRAIL_AUTOMATED_REASONING_FINDING, self) - - def serialize_members(self, serializer: ShapeSerializer): serializer.write_struct( - _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_FINDING.members["invalid"], self.value + hydrate(_SCHEMA_GUARDRAIL_AUTOMATED_REASONING_FINDING), self ) + def serialize_members(self, serializer: ShapeSerializer): + members = hydrate( + _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_FINDING + ).members_by_index + serializer.write_struct(members[1], self.value) + @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: return cls( @@ -3624,14 +3255,16 @@ class GuardrailAutomatedReasoningFindingSatisfiable: value: GuardrailAutomatedReasoningSatisfiableFinding def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_GUARDRAIL_AUTOMATED_REASONING_FINDING, self) - - def serialize_members(self, serializer: ShapeSerializer): serializer.write_struct( - _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_FINDING.members["satisfiable"], - self.value, + hydrate(_SCHEMA_GUARDRAIL_AUTOMATED_REASONING_FINDING), self ) + def serialize_members(self, serializer: ShapeSerializer): + members = hydrate( + _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_FINDING + ).members_by_index + serializer.write_struct(members[2], self.value) + @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: return cls( @@ -3652,14 +3285,16 @@ class GuardrailAutomatedReasoningFindingImpossible: value: GuardrailAutomatedReasoningImpossibleFinding def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_GUARDRAIL_AUTOMATED_REASONING_FINDING, self) - - def serialize_members(self, serializer: ShapeSerializer): serializer.write_struct( - _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_FINDING.members["impossible"], - self.value, + hydrate(_SCHEMA_GUARDRAIL_AUTOMATED_REASONING_FINDING), self ) + def serialize_members(self, serializer: ShapeSerializer): + members = hydrate( + _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_FINDING + ).members_by_index + serializer.write_struct(members[3], self.value) + @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: return cls( @@ -3678,16 +3313,16 @@ class GuardrailAutomatedReasoningFindingTranslationAmbiguous: value: GuardrailAutomatedReasoningTranslationAmbiguousFinding def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_GUARDRAIL_AUTOMATED_REASONING_FINDING, self) - - def serialize_members(self, serializer: ShapeSerializer): serializer.write_struct( - _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_FINDING.members[ - "translationAmbiguous" - ], - self.value, + hydrate(_SCHEMA_GUARDRAIL_AUTOMATED_REASONING_FINDING), self ) + def serialize_members(self, serializer: ShapeSerializer): + members = hydrate( + _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_FINDING + ).members_by_index + serializer.write_struct(members[4], self.value) + @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: return cls( @@ -3708,14 +3343,16 @@ class GuardrailAutomatedReasoningFindingTooComplex: value: GuardrailAutomatedReasoningTooComplexFinding def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_GUARDRAIL_AUTOMATED_REASONING_FINDING, self) - - def serialize_members(self, serializer: ShapeSerializer): serializer.write_struct( - _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_FINDING.members["tooComplex"], - self.value, + hydrate(_SCHEMA_GUARDRAIL_AUTOMATED_REASONING_FINDING), self ) + def serialize_members(self, serializer: ShapeSerializer): + members = hydrate( + _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_FINDING + ).members_by_index + serializer.write_struct(members[5], self.value) + @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: return cls( @@ -3734,14 +3371,16 @@ class GuardrailAutomatedReasoningFindingNoTranslations: value: GuardrailAutomatedReasoningNoTranslationsFinding def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_GUARDRAIL_AUTOMATED_REASONING_FINDING, self) - - def serialize_members(self, serializer: ShapeSerializer): serializer.write_struct( - _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_FINDING.members["noTranslations"], - self.value, + hydrate(_SCHEMA_GUARDRAIL_AUTOMATED_REASONING_FINDING), self ) + def serialize_members(self, serializer: ShapeSerializer): + members = hydrate( + _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_FINDING + ).members_by_index + serializer.write_struct(members[6], self.value) + @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: return cls( @@ -3801,7 +3440,7 @@ def deserialize( ) -> GuardrailAutomatedReasoningFinding: self._result = None deserializer.read_struct( - _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_FINDING, self._consumer + hydrate(_SCHEMA_GUARDRAIL_AUTOMATED_REASONING_FINDING), self._consumer ) if self._result is None: @@ -3870,7 +3509,7 @@ def _serialize_guardrail_automated_reasoning_finding_list( schema: Schema, value: list[GuardrailAutomatedReasoningFinding], ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_struct(member_schema, e) @@ -3909,17 +3548,16 @@ class GuardrailAutomatedReasoningPolicyAssessment: def serialize(self, serializer: ShapeSerializer): serializer.write_struct( - _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_POLICY_ASSESSMENT, self + hydrate(_SCHEMA_GUARDRAIL_AUTOMATED_REASONING_POLICY_ASSESSMENT), self ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate( + _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_POLICY_ASSESSMENT + ).members_by_index if self.findings is not None: _serialize_guardrail_automated_reasoning_finding_list( - serializer, - _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_POLICY_ASSESSMENT.members[ - "findings" - ], - self.findings, + serializer, members[0], self.findings ) @classmethod @@ -3929,25 +3567,22 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_GUARDRAIL_AUTOMATED_REASONING_POLICY_ASSESSMENT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["findings"] = ( _deserialize_guardrail_automated_reasoning_finding_list( - de, - _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_POLICY_ASSESSMENT.members[ - "findings" - ], + de, members[0] ) ) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_POLICY_ASSESSMENT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -4002,28 +3637,18 @@ class GuardrailContentFilter: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_GUARDRAIL_CONTENT_FILTER, self) + serializer.write_struct(hydrate(_SCHEMA_GUARDRAIL_CONTENT_FILTER), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_string( - _SCHEMA_GUARDRAIL_CONTENT_FILTER.members["type"], self.type - ) - serializer.write_string( - _SCHEMA_GUARDRAIL_CONTENT_FILTER.members["confidence"], self.confidence - ) + members = hydrate(_SCHEMA_GUARDRAIL_CONTENT_FILTER).members_by_index + serializer.write_string(members[0], self.type) + serializer.write_string(members[1], self.confidence) if self.filter_strength is not None: - serializer.write_string( - _SCHEMA_GUARDRAIL_CONTENT_FILTER.members["filterStrength"], - self.filter_strength, - ) + serializer.write_string(members[2], self.filter_strength) - serializer.write_string( - _SCHEMA_GUARDRAIL_CONTENT_FILTER.members["action"], self.action - ) + serializer.write_string(members[3], self.action) if self.detected is not None: - serializer.write_boolean( - _SCHEMA_GUARDRAIL_CONTENT_FILTER.members["detected"], self.detected - ) + serializer.write_boolean(members[4], self.detected) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -4032,44 +3657,38 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_GUARDRAIL_CONTENT_FILTER) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["type"] = GuardrailContentFilterType( - de.read_string(_SCHEMA_GUARDRAIL_CONTENT_FILTER.members["type"]) + de.read_string(members[0]) ) case 1: kwargs["confidence"] = GuardrailContentFilterConfidence( - de.read_string( - _SCHEMA_GUARDRAIL_CONTENT_FILTER.members["confidence"] - ) + de.read_string(members[1]) ) case 2: kwargs["filter_strength"] = GuardrailContentFilterStrength( - de.read_string( - _SCHEMA_GUARDRAIL_CONTENT_FILTER.members["filterStrength"] - ) + de.read_string(members[2]) ) case 3: kwargs["action"] = GuardrailContentPolicyAction( - de.read_string( - _SCHEMA_GUARDRAIL_CONTENT_FILTER.members["action"] - ) + de.read_string(members[3]) ) case 4: - kwargs["detected"] = de.read_boolean( - _SCHEMA_GUARDRAIL_CONTENT_FILTER.members["detected"] - ) + kwargs["detected"] = de.read_boolean(members[4]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_GUARDRAIL_CONTENT_FILTER, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) if "type" not in kwargs: kwargs["type"] = GuardrailContentFilterType._corrected("") if "confidence" not in kwargs: @@ -4082,7 +3701,7 @@ def _consumer(schema: Schema, de: ShapeDeserializer) -> None: def _serialize_guardrail_content_filter_list( serializer: ShapeSerializer, schema: Schema, value: list[GuardrailContentFilter] ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_struct(member_schema, e) @@ -4112,14 +3731,13 @@ class GuardrailContentPolicyAssessment: """The content policy filters.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_GUARDRAIL_CONTENT_POLICY_ASSESSMENT, self) + serializer.write_struct( + hydrate(_SCHEMA_GUARDRAIL_CONTENT_POLICY_ASSESSMENT), self + ) def serialize_members(self, serializer: ShapeSerializer): - _serialize_guardrail_content_filter_list( - serializer, - _SCHEMA_GUARDRAIL_CONTENT_POLICY_ASSESSMENT.members["filters"], - self.filters, - ) + members = hydrate(_SCHEMA_GUARDRAIL_CONTENT_POLICY_ASSESSMENT).members_by_index + _serialize_guardrail_content_filter_list(serializer, members[0], self.filters) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -4128,21 +3746,20 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_GUARDRAIL_CONTENT_POLICY_ASSESSMENT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["filters"] = _deserialize_guardrail_content_filter_list( - de, - _SCHEMA_GUARDRAIL_CONTENT_POLICY_ASSESSMENT.members["filters"], + de, members[0] ) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_GUARDRAIL_CONTENT_POLICY_ASSESSMENT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) if "filters" not in kwargs: kwargs["filters"] = [] return kwargs @@ -4185,27 +3802,20 @@ class GuardrailContextualGroundingFilter: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_GUARDRAIL_CONTEXTUAL_GROUNDING_FILTER, self) + serializer.write_struct( + hydrate(_SCHEMA_GUARDRAIL_CONTEXTUAL_GROUNDING_FILTER), self + ) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_string( - _SCHEMA_GUARDRAIL_CONTEXTUAL_GROUNDING_FILTER.members["type"], self.type - ) - serializer.write_double( - _SCHEMA_GUARDRAIL_CONTEXTUAL_GROUNDING_FILTER.members["threshold"], - self.threshold, - ) - serializer.write_double( - _SCHEMA_GUARDRAIL_CONTEXTUAL_GROUNDING_FILTER.members["score"], self.score - ) - serializer.write_string( - _SCHEMA_GUARDRAIL_CONTEXTUAL_GROUNDING_FILTER.members["action"], self.action - ) + members = hydrate( + _SCHEMA_GUARDRAIL_CONTEXTUAL_GROUNDING_FILTER + ).members_by_index + serializer.write_string(members[0], self.type) + serializer.write_double(members[1], self.threshold) + serializer.write_double(members[2], self.score) + serializer.write_string(members[3], self.action) if self.detected is not None: - serializer.write_boolean( - _SCHEMA_GUARDRAIL_CONTEXTUAL_GROUNDING_FILTER.members["detected"], - self.detected, - ) + serializer.write_boolean(members[4], self.detected) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -4214,52 +3824,34 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_GUARDRAIL_CONTEXTUAL_GROUNDING_FILTER) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["type"] = GuardrailContextualGroundingFilterType( - de.read_string( - _SCHEMA_GUARDRAIL_CONTEXTUAL_GROUNDING_FILTER.members[ - "type" - ] - ) + de.read_string(members[0]) ) case 1: - kwargs["threshold"] = de.read_double( - _SCHEMA_GUARDRAIL_CONTEXTUAL_GROUNDING_FILTER.members[ - "threshold" - ] - ) + kwargs["threshold"] = de.read_double(members[1]) case 2: - kwargs["score"] = de.read_double( - _SCHEMA_GUARDRAIL_CONTEXTUAL_GROUNDING_FILTER.members["score"] - ) + kwargs["score"] = de.read_double(members[2]) case 3: kwargs["action"] = GuardrailContextualGroundingPolicyAction( - de.read_string( - _SCHEMA_GUARDRAIL_CONTEXTUAL_GROUNDING_FILTER.members[ - "action" - ] - ) + de.read_string(members[3]) ) case 4: - kwargs["detected"] = de.read_boolean( - _SCHEMA_GUARDRAIL_CONTEXTUAL_GROUNDING_FILTER.members[ - "detected" - ] - ) + kwargs["detected"] = de.read_boolean(members[4]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_GUARDRAIL_CONTEXTUAL_GROUNDING_FILTER, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) if "type" not in kwargs: kwargs["type"] = GuardrailContextualGroundingFilterType._corrected("") if "threshold" not in kwargs: @@ -4276,7 +3868,7 @@ def _serialize_guardrail_contextual_grounding_filters( schema: Schema, value: list[GuardrailContextualGroundingFilter], ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_struct(member_schema, e) @@ -4310,17 +3902,16 @@ class GuardrailContextualGroundingPolicyAssessment: def serialize(self, serializer: ShapeSerializer): serializer.write_struct( - _SCHEMA_GUARDRAIL_CONTEXTUAL_GROUNDING_POLICY_ASSESSMENT, self + hydrate(_SCHEMA_GUARDRAIL_CONTEXTUAL_GROUNDING_POLICY_ASSESSMENT), self ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate( + _SCHEMA_GUARDRAIL_CONTEXTUAL_GROUNDING_POLICY_ASSESSMENT + ).members_by_index if self.filters is not None: _serialize_guardrail_contextual_grounding_filters( - serializer, - _SCHEMA_GUARDRAIL_CONTEXTUAL_GROUNDING_POLICY_ASSESSMENT.members[ - "filters" - ], - self.filters, + serializer, members[0], self.filters ) @classmethod @@ -4330,25 +3921,22 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_GUARDRAIL_CONTEXTUAL_GROUNDING_POLICY_ASSESSMENT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["filters"] = ( _deserialize_guardrail_contextual_grounding_filters( - de, - _SCHEMA_GUARDRAIL_CONTEXTUAL_GROUNDING_POLICY_ASSESSMENT.members[ - "filters" - ], + de, members[0] ) ) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_GUARDRAIL_CONTEXTUAL_GROUNDING_POLICY_ASSESSMENT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -4366,18 +3954,15 @@ class GuardrailImageCoverage: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_GUARDRAIL_IMAGE_COVERAGE, self) + serializer.write_struct(hydrate(_SCHEMA_GUARDRAIL_IMAGE_COVERAGE), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_GUARDRAIL_IMAGE_COVERAGE).members_by_index if self.guarded is not None: - serializer.write_integer( - _SCHEMA_GUARDRAIL_IMAGE_COVERAGE.members["guarded"], self.guarded - ) + serializer.write_integer(members[0], self.guarded) if self.total is not None: - serializer.write_integer( - _SCHEMA_GUARDRAIL_IMAGE_COVERAGE.members["total"], self.total - ) + serializer.write_integer(members[1], self.total) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -4386,23 +3971,21 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_GUARDRAIL_IMAGE_COVERAGE) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["guarded"] = de.read_integer( - _SCHEMA_GUARDRAIL_IMAGE_COVERAGE.members["guarded"] - ) + kwargs["guarded"] = de.read_integer(members[0]) case 1: - kwargs["total"] = de.read_integer( - _SCHEMA_GUARDRAIL_IMAGE_COVERAGE.members["total"] - ) + kwargs["total"] = de.read_integer(members[1]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_GUARDRAIL_IMAGE_COVERAGE, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -4417,19 +4000,17 @@ class GuardrailTextCharactersCoverage: """The total text characters by the guardrail coverage.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_GUARDRAIL_TEXT_CHARACTERS_COVERAGE, self) + serializer.write_struct( + hydrate(_SCHEMA_GUARDRAIL_TEXT_CHARACTERS_COVERAGE), self + ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_GUARDRAIL_TEXT_CHARACTERS_COVERAGE).members_by_index if self.guarded is not None: - serializer.write_integer( - _SCHEMA_GUARDRAIL_TEXT_CHARACTERS_COVERAGE.members["guarded"], - self.guarded, - ) + serializer.write_integer(members[0], self.guarded) if self.total is not None: - serializer.write_integer( - _SCHEMA_GUARDRAIL_TEXT_CHARACTERS_COVERAGE.members["total"], self.total - ) + serializer.write_integer(members[1], self.total) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -4438,25 +4019,21 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_GUARDRAIL_TEXT_CHARACTERS_COVERAGE) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["guarded"] = de.read_integer( - _SCHEMA_GUARDRAIL_TEXT_CHARACTERS_COVERAGE.members["guarded"] - ) + kwargs["guarded"] = de.read_integer(members[0]) case 1: - kwargs["total"] = de.read_integer( - _SCHEMA_GUARDRAIL_TEXT_CHARACTERS_COVERAGE.members["total"] - ) + kwargs["total"] = de.read_integer(members[1]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_GUARDRAIL_TEXT_CHARACTERS_COVERAGE, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -4474,19 +4051,15 @@ class GuardrailCoverage: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_GUARDRAIL_COVERAGE, self) + serializer.write_struct(hydrate(_SCHEMA_GUARDRAIL_COVERAGE), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_GUARDRAIL_COVERAGE).members_by_index if self.text_characters is not None: - serializer.write_struct( - _SCHEMA_GUARDRAIL_COVERAGE.members["textCharacters"], - self.text_characters, - ) + serializer.write_struct(members[0], self.text_characters) if self.images is not None: - serializer.write_struct( - _SCHEMA_GUARDRAIL_COVERAGE.members["images"], self.images - ) + serializer.write_struct(members[1], self.images) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -4495,9 +4068,11 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_GUARDRAIL_COVERAGE) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["text_characters"] = ( GuardrailTextCharactersCoverage.deserialize(de) @@ -4507,9 +4082,9 @@ def _consumer(schema: Schema, de: ShapeDeserializer) -> None: kwargs["images"] = GuardrailImageCoverage.deserialize(de) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_GUARDRAIL_COVERAGE, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -4548,48 +4123,26 @@ class GuardrailUsage: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_GUARDRAIL_USAGE, self) + serializer.write_struct(hydrate(_SCHEMA_GUARDRAIL_USAGE), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_GUARDRAIL_USAGE).members_by_index + serializer.write_integer(members[0], self.topic_policy_units) + serializer.write_integer(members[1], self.content_policy_units) + serializer.write_integer(members[2], self.word_policy_units) + serializer.write_integer(members[3], self.sensitive_information_policy_units) serializer.write_integer( - _SCHEMA_GUARDRAIL_USAGE.members["topicPolicyUnits"], self.topic_policy_units - ) - serializer.write_integer( - _SCHEMA_GUARDRAIL_USAGE.members["contentPolicyUnits"], - self.content_policy_units, - ) - serializer.write_integer( - _SCHEMA_GUARDRAIL_USAGE.members["wordPolicyUnits"], self.word_policy_units - ) - serializer.write_integer( - _SCHEMA_GUARDRAIL_USAGE.members["sensitiveInformationPolicyUnits"], - self.sensitive_information_policy_units, - ) - serializer.write_integer( - _SCHEMA_GUARDRAIL_USAGE.members["sensitiveInformationPolicyFreeUnits"], - self.sensitive_information_policy_free_units, - ) - serializer.write_integer( - _SCHEMA_GUARDRAIL_USAGE.members["contextualGroundingPolicyUnits"], - self.contextual_grounding_policy_units, + members[4], self.sensitive_information_policy_free_units ) + serializer.write_integer(members[5], self.contextual_grounding_policy_units) if self.content_policy_image_units is not None: - serializer.write_integer( - _SCHEMA_GUARDRAIL_USAGE.members["contentPolicyImageUnits"], - self.content_policy_image_units, - ) + serializer.write_integer(members[6], self.content_policy_image_units) if self.automated_reasoning_policy_units is not None: - serializer.write_integer( - _SCHEMA_GUARDRAIL_USAGE.members["automatedReasoningPolicyUnits"], - self.automated_reasoning_policy_units, - ) + serializer.write_integer(members[7], self.automated_reasoning_policy_units) if self.automated_reasoning_policies is not None: - serializer.write_integer( - _SCHEMA_GUARDRAIL_USAGE.members["automatedReasoningPolicies"], - self.automated_reasoning_policies, - ) + serializer.write_integer(members[8], self.automated_reasoning_policies) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -4598,64 +4151,50 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_GUARDRAIL_USAGE) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["topic_policy_units"] = de.read_integer( - _SCHEMA_GUARDRAIL_USAGE.members["topicPolicyUnits"] - ) + kwargs["topic_policy_units"] = de.read_integer(members[0]) case 1: - kwargs["content_policy_units"] = de.read_integer( - _SCHEMA_GUARDRAIL_USAGE.members["contentPolicyUnits"] - ) + kwargs["content_policy_units"] = de.read_integer(members[1]) case 2: - kwargs["word_policy_units"] = de.read_integer( - _SCHEMA_GUARDRAIL_USAGE.members["wordPolicyUnits"] - ) + kwargs["word_policy_units"] = de.read_integer(members[2]) case 3: kwargs["sensitive_information_policy_units"] = de.read_integer( - _SCHEMA_GUARDRAIL_USAGE.members[ - "sensitiveInformationPolicyUnits" - ] + members[3] ) case 4: kwargs["sensitive_information_policy_free_units"] = de.read_integer( - _SCHEMA_GUARDRAIL_USAGE.members[ - "sensitiveInformationPolicyFreeUnits" - ] + members[4] ) case 5: kwargs["contextual_grounding_policy_units"] = de.read_integer( - _SCHEMA_GUARDRAIL_USAGE.members[ - "contextualGroundingPolicyUnits" - ] + members[5] ) case 6: - kwargs["content_policy_image_units"] = de.read_integer( - _SCHEMA_GUARDRAIL_USAGE.members["contentPolicyImageUnits"] - ) + kwargs["content_policy_image_units"] = de.read_integer(members[6]) case 7: kwargs["automated_reasoning_policy_units"] = de.read_integer( - _SCHEMA_GUARDRAIL_USAGE.members["automatedReasoningPolicyUnits"] + members[7] ) case 8: - kwargs["automated_reasoning_policies"] = de.read_integer( - _SCHEMA_GUARDRAIL_USAGE.members["automatedReasoningPolicies"] - ) + kwargs["automated_reasoning_policies"] = de.read_integer(members[8]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_GUARDRAIL_USAGE, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) if "topic_policy_units" not in kwargs: kwargs["topic_policy_units"] = 0 if "content_policy_units" not in kwargs: @@ -4696,27 +4235,18 @@ class GuardrailInvocationMetrics: """The coverage details for the guardrail invocation metrics.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_GUARDRAIL_INVOCATION_METRICS, self) + serializer.write_struct(hydrate(_SCHEMA_GUARDRAIL_INVOCATION_METRICS), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_GUARDRAIL_INVOCATION_METRICS).members_by_index if self.guardrail_processing_latency is not None: - serializer.write_long( - _SCHEMA_GUARDRAIL_INVOCATION_METRICS.members[ - "guardrailProcessingLatency" - ], - self.guardrail_processing_latency, - ) + serializer.write_long(members[0], self.guardrail_processing_latency) if self.usage is not None: - serializer.write_struct( - _SCHEMA_GUARDRAIL_INVOCATION_METRICS.members["usage"], self.usage - ) + serializer.write_struct(members[1], self.usage) if self.guardrail_coverage is not None: - serializer.write_struct( - _SCHEMA_GUARDRAIL_INVOCATION_METRICS.members["guardrailCoverage"], - self.guardrail_coverage, - ) + serializer.write_struct(members[2], self.guardrail_coverage) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -4725,15 +4255,13 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_GUARDRAIL_INVOCATION_METRICS) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["guardrail_processing_latency"] = de.read_long( - _SCHEMA_GUARDRAIL_INVOCATION_METRICS.members[ - "guardrailProcessingLatency" - ] - ) + kwargs["guardrail_processing_latency"] = de.read_long(members[0]) case 1: kwargs["usage"] = GuardrailUsage.deserialize(de) @@ -4742,11 +4270,9 @@ def _consumer(schema: Schema, de: ShapeDeserializer) -> None: kwargs["guardrail_coverage"] = GuardrailCoverage.deserialize(de) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_GUARDRAIL_INVOCATION_METRICS, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -4813,22 +4339,15 @@ class GuardrailPiiEntityFilter: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_GUARDRAIL_PII_ENTITY_FILTER, self) + serializer.write_struct(hydrate(_SCHEMA_GUARDRAIL_PII_ENTITY_FILTER), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_string( - _SCHEMA_GUARDRAIL_PII_ENTITY_FILTER.members["match"], self.match - ) - serializer.write_string( - _SCHEMA_GUARDRAIL_PII_ENTITY_FILTER.members["type"], self.type - ) - serializer.write_string( - _SCHEMA_GUARDRAIL_PII_ENTITY_FILTER.members["action"], self.action - ) + members = hydrate(_SCHEMA_GUARDRAIL_PII_ENTITY_FILTER).members_by_index + serializer.write_string(members[0], self.match) + serializer.write_string(members[1], self.type) + serializer.write_string(members[2], self.action) if self.detected is not None: - serializer.write_boolean( - _SCHEMA_GUARDRAIL_PII_ENTITY_FILTER.members["detected"], self.detected - ) + serializer.write_boolean(members[3], self.detected) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -4837,39 +4356,29 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_GUARDRAIL_PII_ENTITY_FILTER) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["match"] = de.read_string( - _SCHEMA_GUARDRAIL_PII_ENTITY_FILTER.members["match"] - ) + kwargs["match"] = de.read_string(members[0]) case 1: - kwargs["type"] = GuardrailPiiEntityType( - de.read_string( - _SCHEMA_GUARDRAIL_PII_ENTITY_FILTER.members["type"] - ) - ) + kwargs["type"] = GuardrailPiiEntityType(de.read_string(members[1])) case 2: kwargs["action"] = GuardrailSensitiveInformationPolicyAction( - de.read_string( - _SCHEMA_GUARDRAIL_PII_ENTITY_FILTER.members["action"] - ) + de.read_string(members[2]) ) case 3: - kwargs["detected"] = de.read_boolean( - _SCHEMA_GUARDRAIL_PII_ENTITY_FILTER.members["detected"] - ) + kwargs["detected"] = de.read_boolean(members[3]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_GUARDRAIL_PII_ENTITY_FILTER, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) if "match" not in kwargs: kwargs["match"] = "" if "type" not in kwargs: @@ -4882,7 +4391,7 @@ def _consumer(schema: Schema, de: ShapeDeserializer) -> None: def _serialize_guardrail_pii_entity_filter_list( serializer: ShapeSerializer, schema: Schema, value: list[GuardrailPiiEntityFilter] ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_struct(member_schema, e) @@ -4927,31 +4436,22 @@ class GuardrailRegexFilter: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_GUARDRAIL_REGEX_FILTER, self) + serializer.write_struct(hydrate(_SCHEMA_GUARDRAIL_REGEX_FILTER), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_GUARDRAIL_REGEX_FILTER).members_by_index if self.name is not None: - serializer.write_string( - _SCHEMA_GUARDRAIL_REGEX_FILTER.members["name"], self.name - ) + serializer.write_string(members[0], self.name) if self.match is not None: - serializer.write_string( - _SCHEMA_GUARDRAIL_REGEX_FILTER.members["match"], self.match - ) + serializer.write_string(members[1], self.match) if self.regex is not None: - serializer.write_string( - _SCHEMA_GUARDRAIL_REGEX_FILTER.members["regex"], self.regex - ) + serializer.write_string(members[2], self.regex) - serializer.write_string( - _SCHEMA_GUARDRAIL_REGEX_FILTER.members["action"], self.action - ) + serializer.write_string(members[3], self.action) if self.detected is not None: - serializer.write_boolean( - _SCHEMA_GUARDRAIL_REGEX_FILTER.members["detected"], self.detected - ) + serializer.write_boolean(members[4], self.detected) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -4960,38 +4460,32 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_GUARDRAIL_REGEX_FILTER) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["name"] = de.read_string( - _SCHEMA_GUARDRAIL_REGEX_FILTER.members["name"] - ) + kwargs["name"] = de.read_string(members[0]) case 1: - kwargs["match"] = de.read_string( - _SCHEMA_GUARDRAIL_REGEX_FILTER.members["match"] - ) + kwargs["match"] = de.read_string(members[1]) case 2: - kwargs["regex"] = de.read_string( - _SCHEMA_GUARDRAIL_REGEX_FILTER.members["regex"] - ) + kwargs["regex"] = de.read_string(members[2]) case 3: kwargs["action"] = GuardrailSensitiveInformationPolicyAction( - de.read_string(_SCHEMA_GUARDRAIL_REGEX_FILTER.members["action"]) + de.read_string(members[3]) ) case 4: - kwargs["detected"] = de.read_boolean( - _SCHEMA_GUARDRAIL_REGEX_FILTER.members["detected"] - ) + kwargs["detected"] = de.read_boolean(members[4]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_GUARDRAIL_REGEX_FILTER, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) if "action" not in kwargs: kwargs["action"] = GuardrailSensitiveInformationPolicyAction._corrected("") return kwargs @@ -5000,7 +4494,7 @@ def _consumer(schema: Schema, de: ShapeDeserializer) -> None: def _serialize_guardrail_regex_filter_list( serializer: ShapeSerializer, schema: Schema, value: list[GuardrailRegexFilter] ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_struct(member_schema, e) @@ -5034,24 +4528,17 @@ class GuardrailSensitiveInformationPolicyAssessment: def serialize(self, serializer: ShapeSerializer): serializer.write_struct( - _SCHEMA_GUARDRAIL_SENSITIVE_INFORMATION_POLICY_ASSESSMENT, self + hydrate(_SCHEMA_GUARDRAIL_SENSITIVE_INFORMATION_POLICY_ASSESSMENT), self ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate( + _SCHEMA_GUARDRAIL_SENSITIVE_INFORMATION_POLICY_ASSESSMENT + ).members_by_index _serialize_guardrail_pii_entity_filter_list( - serializer, - _SCHEMA_GUARDRAIL_SENSITIVE_INFORMATION_POLICY_ASSESSMENT.members[ - "piiEntities" - ], - self.pii_entities, - ) - _serialize_guardrail_regex_filter_list( - serializer, - _SCHEMA_GUARDRAIL_SENSITIVE_INFORMATION_POLICY_ASSESSMENT.members[ - "regexes" - ], - self.regexes, + serializer, members[0], self.pii_entities ) + _serialize_guardrail_regex_filter_list(serializer, members[1], self.regexes) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -5060,34 +4547,25 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_GUARDRAIL_SENSITIVE_INFORMATION_POLICY_ASSESSMENT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["pii_entities"] = ( - _deserialize_guardrail_pii_entity_filter_list( - de, - _SCHEMA_GUARDRAIL_SENSITIVE_INFORMATION_POLICY_ASSESSMENT.members[ - "piiEntities" - ], - ) + _deserialize_guardrail_pii_entity_filter_list(de, members[0]) ) case 1: kwargs["regexes"] = _deserialize_guardrail_regex_filter_list( - de, - _SCHEMA_GUARDRAIL_SENSITIVE_INFORMATION_POLICY_ASSESSMENT.members[ - "regexes" - ], + de, members[1] ) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_GUARDRAIL_SENSITIVE_INFORMATION_POLICY_ASSESSMENT, - consumer=_consumer, - ) + deserializer.read_struct(schema, consumer=_consumer) if "pii_entities" not in kwargs: kwargs["pii_entities"] = [] if "regexes" not in kwargs: @@ -5127,16 +4605,15 @@ class GuardrailTopic: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_GUARDRAIL_TOPIC, self) + serializer.write_struct(hydrate(_SCHEMA_GUARDRAIL_TOPIC), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_string(_SCHEMA_GUARDRAIL_TOPIC.members["name"], self.name) - serializer.write_string(_SCHEMA_GUARDRAIL_TOPIC.members["type"], self.type) - serializer.write_string(_SCHEMA_GUARDRAIL_TOPIC.members["action"], self.action) + members = hydrate(_SCHEMA_GUARDRAIL_TOPIC).members_by_index + serializer.write_string(members[0], self.name) + serializer.write_string(members[1], self.type) + serializer.write_string(members[2], self.action) if self.detected is not None: - serializer.write_boolean( - _SCHEMA_GUARDRAIL_TOPIC.members["detected"], self.detected - ) + serializer.write_boolean(members[3], self.detected) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -5145,33 +4622,29 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_GUARDRAIL_TOPIC) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["name"] = de.read_string( - _SCHEMA_GUARDRAIL_TOPIC.members["name"] - ) + kwargs["name"] = de.read_string(members[0]) case 1: - kwargs["type"] = GuardrailTopicType( - de.read_string(_SCHEMA_GUARDRAIL_TOPIC.members["type"]) - ) + kwargs["type"] = GuardrailTopicType(de.read_string(members[1])) case 2: kwargs["action"] = GuardrailTopicPolicyAction( - de.read_string(_SCHEMA_GUARDRAIL_TOPIC.members["action"]) + de.read_string(members[2]) ) case 3: - kwargs["detected"] = de.read_boolean( - _SCHEMA_GUARDRAIL_TOPIC.members["detected"] - ) + kwargs["detected"] = de.read_boolean(members[3]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_GUARDRAIL_TOPIC, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) if "name" not in kwargs: kwargs["name"] = "" if "type" not in kwargs: @@ -5184,7 +4657,7 @@ def _consumer(schema: Schema, de: ShapeDeserializer) -> None: def _serialize_guardrail_topic_list( serializer: ShapeSerializer, schema: Schema, value: list[GuardrailTopic] ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_struct(member_schema, e) @@ -5214,14 +4687,13 @@ class GuardrailTopicPolicyAssessment: """The topics in the assessment.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_GUARDRAIL_TOPIC_POLICY_ASSESSMENT, self) + serializer.write_struct( + hydrate(_SCHEMA_GUARDRAIL_TOPIC_POLICY_ASSESSMENT), self + ) def serialize_members(self, serializer: ShapeSerializer): - _serialize_guardrail_topic_list( - serializer, - _SCHEMA_GUARDRAIL_TOPIC_POLICY_ASSESSMENT.members["topics"], - self.topics, - ) + members = hydrate(_SCHEMA_GUARDRAIL_TOPIC_POLICY_ASSESSMENT).members_by_index + _serialize_guardrail_topic_list(serializer, members[0], self.topics) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -5230,20 +4702,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_GUARDRAIL_TOPIC_POLICY_ASSESSMENT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["topics"] = _deserialize_guardrail_topic_list( - de, _SCHEMA_GUARDRAIL_TOPIC_POLICY_ASSESSMENT.members["topics"] - ) + kwargs["topics"] = _deserialize_guardrail_topic_list(de, members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_GUARDRAIL_TOPIC_POLICY_ASSESSMENT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) if "topics" not in kwargs: kwargs["topics"] = [] return kwargs @@ -5271,19 +4741,14 @@ class GuardrailCustomWord: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_GUARDRAIL_CUSTOM_WORD, self) + serializer.write_struct(hydrate(_SCHEMA_GUARDRAIL_CUSTOM_WORD), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_string( - _SCHEMA_GUARDRAIL_CUSTOM_WORD.members["match"], self.match - ) - serializer.write_string( - _SCHEMA_GUARDRAIL_CUSTOM_WORD.members["action"], self.action - ) + members = hydrate(_SCHEMA_GUARDRAIL_CUSTOM_WORD).members_by_index + serializer.write_string(members[0], self.match) + serializer.write_string(members[1], self.action) if self.detected is not None: - serializer.write_boolean( - _SCHEMA_GUARDRAIL_CUSTOM_WORD.members["detected"], self.detected - ) + serializer.write_boolean(members[2], self.detected) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -5292,28 +4757,26 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_GUARDRAIL_CUSTOM_WORD) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["match"] = de.read_string( - _SCHEMA_GUARDRAIL_CUSTOM_WORD.members["match"] - ) + kwargs["match"] = de.read_string(members[0]) case 1: kwargs["action"] = GuardrailWordPolicyAction( - de.read_string(_SCHEMA_GUARDRAIL_CUSTOM_WORD.members["action"]) + de.read_string(members[1]) ) case 2: - kwargs["detected"] = de.read_boolean( - _SCHEMA_GUARDRAIL_CUSTOM_WORD.members["detected"] - ) + kwargs["detected"] = de.read_boolean(members[2]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_GUARDRAIL_CUSTOM_WORD, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) if "match" not in kwargs: kwargs["match"] = "" if "action" not in kwargs: @@ -5324,7 +4787,7 @@ def _consumer(schema: Schema, de: ShapeDeserializer) -> None: def _serialize_guardrail_custom_word_list( serializer: ShapeSerializer, schema: Schema, value: list[GuardrailCustomWord] ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_struct(member_schema, e) @@ -5370,22 +4833,15 @@ class GuardrailManagedWord: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_GUARDRAIL_MANAGED_WORD, self) + serializer.write_struct(hydrate(_SCHEMA_GUARDRAIL_MANAGED_WORD), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_string( - _SCHEMA_GUARDRAIL_MANAGED_WORD.members["match"], self.match - ) - serializer.write_string( - _SCHEMA_GUARDRAIL_MANAGED_WORD.members["type"], self.type - ) - serializer.write_string( - _SCHEMA_GUARDRAIL_MANAGED_WORD.members["action"], self.action - ) + members = hydrate(_SCHEMA_GUARDRAIL_MANAGED_WORD).members_by_index + serializer.write_string(members[0], self.match) + serializer.write_string(members[1], self.type) + serializer.write_string(members[2], self.action) if self.detected is not None: - serializer.write_boolean( - _SCHEMA_GUARDRAIL_MANAGED_WORD.members["detected"], self.detected - ) + serializer.write_boolean(members[3], self.detected) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -5394,33 +4850,31 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_GUARDRAIL_MANAGED_WORD) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["match"] = de.read_string( - _SCHEMA_GUARDRAIL_MANAGED_WORD.members["match"] - ) + kwargs["match"] = de.read_string(members[0]) case 1: kwargs["type"] = GuardrailManagedWordType( - de.read_string(_SCHEMA_GUARDRAIL_MANAGED_WORD.members["type"]) + de.read_string(members[1]) ) case 2: kwargs["action"] = GuardrailWordPolicyAction( - de.read_string(_SCHEMA_GUARDRAIL_MANAGED_WORD.members["action"]) + de.read_string(members[2]) ) case 3: - kwargs["detected"] = de.read_boolean( - _SCHEMA_GUARDRAIL_MANAGED_WORD.members["detected"] - ) + kwargs["detected"] = de.read_boolean(members[3]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_GUARDRAIL_MANAGED_WORD, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) if "match" not in kwargs: kwargs["match"] = "" if "type" not in kwargs: @@ -5433,7 +4887,7 @@ def _consumer(schema: Schema, de: ShapeDeserializer) -> None: def _serialize_guardrail_managed_word_list( serializer: ShapeSerializer, schema: Schema, value: list[GuardrailManagedWord] ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_struct(member_schema, e) @@ -5466,18 +4920,13 @@ class GuardrailWordPolicyAssessment: """Managed word lists in the assessment.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_GUARDRAIL_WORD_POLICY_ASSESSMENT, self) + serializer.write_struct(hydrate(_SCHEMA_GUARDRAIL_WORD_POLICY_ASSESSMENT), self) def serialize_members(self, serializer: ShapeSerializer): - _serialize_guardrail_custom_word_list( - serializer, - _SCHEMA_GUARDRAIL_WORD_POLICY_ASSESSMENT.members["customWords"], - self.custom_words, - ) + members = hydrate(_SCHEMA_GUARDRAIL_WORD_POLICY_ASSESSMENT).members_by_index + _serialize_guardrail_custom_word_list(serializer, members[0], self.custom_words) _serialize_guardrail_managed_word_list( - serializer, - _SCHEMA_GUARDRAIL_WORD_POLICY_ASSESSMENT.members["managedWordLists"], - self.managed_word_lists, + serializer, members[1], self.managed_word_lists ) @classmethod @@ -5487,31 +4936,25 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_GUARDRAIL_WORD_POLICY_ASSESSMENT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["custom_words"] = _deserialize_guardrail_custom_word_list( - de, - _SCHEMA_GUARDRAIL_WORD_POLICY_ASSESSMENT.members["customWords"], + de, members[0] ) case 1: kwargs["managed_word_lists"] = ( - _deserialize_guardrail_managed_word_list( - de, - _SCHEMA_GUARDRAIL_WORD_POLICY_ASSESSMENT.members[ - "managedWordLists" - ], - ) + _deserialize_guardrail_managed_word_list(de, members[1]) ) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_GUARDRAIL_WORD_POLICY_ASSESSMENT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) if "custom_words" not in kwargs: kwargs["custom_words"] = [] if "managed_word_lists" not in kwargs: @@ -5564,54 +5007,33 @@ class GuardrailAssessment: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_GUARDRAIL_ASSESSMENT, self) + serializer.write_struct(hydrate(_SCHEMA_GUARDRAIL_ASSESSMENT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_GUARDRAIL_ASSESSMENT).members_by_index if self.topic_policy is not None: - serializer.write_struct( - _SCHEMA_GUARDRAIL_ASSESSMENT.members["topicPolicy"], self.topic_policy - ) + serializer.write_struct(members[0], self.topic_policy) if self.content_policy is not None: - serializer.write_struct( - _SCHEMA_GUARDRAIL_ASSESSMENT.members["contentPolicy"], - self.content_policy, - ) + serializer.write_struct(members[1], self.content_policy) if self.word_policy is not None: - serializer.write_struct( - _SCHEMA_GUARDRAIL_ASSESSMENT.members["wordPolicy"], self.word_policy - ) + serializer.write_struct(members[2], self.word_policy) if self.sensitive_information_policy is not None: - serializer.write_struct( - _SCHEMA_GUARDRAIL_ASSESSMENT.members["sensitiveInformationPolicy"], - self.sensitive_information_policy, - ) + serializer.write_struct(members[3], self.sensitive_information_policy) if self.contextual_grounding_policy is not None: - serializer.write_struct( - _SCHEMA_GUARDRAIL_ASSESSMENT.members["contextualGroundingPolicy"], - self.contextual_grounding_policy, - ) + serializer.write_struct(members[4], self.contextual_grounding_policy) if self.automated_reasoning_policy is not None: - serializer.write_struct( - _SCHEMA_GUARDRAIL_ASSESSMENT.members["automatedReasoningPolicy"], - self.automated_reasoning_policy, - ) + serializer.write_struct(members[5], self.automated_reasoning_policy) if self.invocation_metrics is not None: - serializer.write_struct( - _SCHEMA_GUARDRAIL_ASSESSMENT.members["invocationMetrics"], - self.invocation_metrics, - ) + serializer.write_struct(members[6], self.invocation_metrics) if self.applied_guardrail_details is not None: - serializer.write_struct( - _SCHEMA_GUARDRAIL_ASSESSMENT.members["appliedGuardrailDetails"], - self.applied_guardrail_details, - ) + serializer.write_struct(members[7], self.applied_guardrail_details) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -5620,9 +5042,11 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_GUARDRAIL_ASSESSMENT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["topic_policy"] = GuardrailTopicPolicyAssessment.deserialize( de @@ -5664,16 +5088,16 @@ def _consumer(schema: Schema, de: ShapeDeserializer) -> None: ) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_GUARDRAIL_ASSESSMENT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs def _serialize_guardrail_assessment_list( serializer: ShapeSerializer, schema: Schema, value: list[GuardrailAssessment] ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_struct(member_schema, e) @@ -5703,13 +5127,12 @@ class GuardrailOutputContent: """The specific text for the output content produced by the guardrail.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_GUARDRAIL_OUTPUT_CONTENT, self) + serializer.write_struct(hydrate(_SCHEMA_GUARDRAIL_OUTPUT_CONTENT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_GUARDRAIL_OUTPUT_CONTENT).members_by_index if self.text is not None: - serializer.write_string( - _SCHEMA_GUARDRAIL_OUTPUT_CONTENT.members["text"], self.text - ) + serializer.write_string(members[0], self.text) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -5718,25 +5141,25 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_GUARDRAIL_OUTPUT_CONTENT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["text"] = de.read_string( - _SCHEMA_GUARDRAIL_OUTPUT_CONTENT.members["text"] - ) + kwargs["text"] = de.read_string(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_GUARDRAIL_OUTPUT_CONTENT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs def _serialize_guardrail_output_content_list( serializer: ShapeSerializer, schema: Schema, value: list[GuardrailOutputContent] ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_struct(member_schema, e) @@ -5791,34 +5214,19 @@ class ApplyGuardrailOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_APPLY_GUARDRAIL_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_APPLY_GUARDRAIL_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_struct( - _SCHEMA_APPLY_GUARDRAIL_OUTPUT.members["usage"], self.usage - ) - serializer.write_string( - _SCHEMA_APPLY_GUARDRAIL_OUTPUT.members["action"], self.action - ) + members = hydrate(_SCHEMA_APPLY_GUARDRAIL_OUTPUT).members_by_index + serializer.write_struct(members[0], self.usage) + serializer.write_string(members[1], self.action) if self.action_reason is not None: - serializer.write_string( - _SCHEMA_APPLY_GUARDRAIL_OUTPUT.members["actionReason"], - self.action_reason, - ) + serializer.write_string(members[2], self.action_reason) - _serialize_guardrail_output_content_list( - serializer, _SCHEMA_APPLY_GUARDRAIL_OUTPUT.members["outputs"], self.outputs - ) - _serialize_guardrail_assessment_list( - serializer, - _SCHEMA_APPLY_GUARDRAIL_OUTPUT.members["assessments"], - self.assessments, - ) + _serialize_guardrail_output_content_list(serializer, members[3], self.outputs) + _serialize_guardrail_assessment_list(serializer, members[4], self.assessments) if self.guardrail_coverage is not None: - serializer.write_struct( - _SCHEMA_APPLY_GUARDRAIL_OUTPUT.members["guardrailCoverage"], - self.guardrail_coverage, - ) + serializer.write_struct(members[5], self.guardrail_coverage) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -5827,39 +5235,37 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_APPLY_GUARDRAIL_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["usage"] = GuardrailUsage.deserialize(de) case 1: - kwargs["action"] = GuardrailAction( - de.read_string(_SCHEMA_APPLY_GUARDRAIL_OUTPUT.members["action"]) - ) + kwargs["action"] = GuardrailAction(de.read_string(members[1])) case 2: - kwargs["action_reason"] = de.read_string( - _SCHEMA_APPLY_GUARDRAIL_OUTPUT.members["actionReason"] - ) + kwargs["action_reason"] = de.read_string(members[2]) case 3: kwargs["outputs"] = _deserialize_guardrail_output_content_list( - de, _SCHEMA_APPLY_GUARDRAIL_OUTPUT.members["outputs"] + de, members[3] ) case 4: kwargs["assessments"] = _deserialize_guardrail_assessment_list( - de, _SCHEMA_APPLY_GUARDRAIL_OUTPUT.members["assessments"] + de, members[4] ) case 5: kwargs["guardrail_coverage"] = GuardrailCoverage.deserialize(de) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_APPLY_GUARDRAIL_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) if "usage" not in kwargs: kwargs["usage"] = GuardrailUsage._smithy_default() if "action" not in kwargs: @@ -5874,9 +5280,7 @@ def _consumer(schema: Schema, de: ShapeDeserializer) -> None: APPLY_GUARDRAIL = APIOperation( input=ApplyGuardrailInput, output=ApplyGuardrailOutput, - schema=_SCHEMA_APPLY_GUARDRAIL, - input_schema=_SCHEMA_APPLY_GUARDRAIL_INPUT, - output_schema=_SCHEMA_APPLY_GUARDRAIL_OUTPUT, + static_schema=_SCHEMA_APPLY_GUARDRAIL, error_registry=TypeRegistry( { ShapeID( @@ -5906,15 +5310,6 @@ def _consumer(schema: Schema, de: ShapeDeserializer) -> None: ShapeID("aws.auth#sigv4"), ShapeID("smithy.api#httpBearerAuth"), ], - error_schemas=[ - _SCHEMA_ACCESS_DENIED_EXCEPTION, - _SCHEMA_INTERNAL_SERVER_EXCEPTION, - _SCHEMA_RESOURCE_NOT_FOUND_EXCEPTION, - _SCHEMA_SERVICE_QUOTA_EXCEEDED_EXCEPTION, - _SCHEMA_SERVICE_UNAVAILABLE_EXCEPTION, - _SCHEMA_THROTTLING_EXCEPTION, - _SCHEMA_VALIDATION_EXCEPTION, - ], ) @@ -5937,14 +5332,14 @@ class GuardrailChecksContentFilterCategoryConfig: def serialize(self, serializer: ShapeSerializer): serializer.write_struct( - _SCHEMA_GUARDRAIL_CHECKS_CONTENT_FILTER_CATEGORY_CONFIG, self + hydrate(_SCHEMA_GUARDRAIL_CHECKS_CONTENT_FILTER_CATEGORY_CONFIG), self ) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_string( - _SCHEMA_GUARDRAIL_CHECKS_CONTENT_FILTER_CATEGORY_CONFIG.members["category"], - self.category, - ) + members = hydrate( + _SCHEMA_GUARDRAIL_CHECKS_CONTENT_FILTER_CATEGORY_CONFIG + ).members_by_index + serializer.write_string(members[0], self.category) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -5953,24 +5348,20 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_GUARDRAIL_CHECKS_CONTENT_FILTER_CATEGORY_CONFIG) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["category"] = GuardrailChecksContentFilterCategory( - de.read_string( - _SCHEMA_GUARDRAIL_CHECKS_CONTENT_FILTER_CATEGORY_CONFIG.members[ - "category" - ] - ) + de.read_string(members[0]) ) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_GUARDRAIL_CHECKS_CONTENT_FILTER_CATEGORY_CONFIG, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) if "category" not in kwargs: kwargs["category"] = GuardrailChecksContentFilterCategory._corrected("") return kwargs @@ -5981,7 +5372,7 @@ def _serialize_guardrail_checks_content_filter_category_config_list( schema: Schema, value: list[GuardrailChecksContentFilterCategoryConfig], ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_struct(member_schema, e) @@ -6014,13 +5405,16 @@ class GuardrailChecksContentFilterConfig: """The content filter categories to evaluate.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_GUARDRAIL_CHECKS_CONTENT_FILTER_CONFIG, self) + serializer.write_struct( + hydrate(_SCHEMA_GUARDRAIL_CHECKS_CONTENT_FILTER_CONFIG), self + ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate( + _SCHEMA_GUARDRAIL_CHECKS_CONTENT_FILTER_CONFIG + ).members_by_index _serialize_guardrail_checks_content_filter_category_config_list( - serializer, - _SCHEMA_GUARDRAIL_CHECKS_CONTENT_FILTER_CONFIG.members["categories"], - self.categories, + serializer, members[0], self.categories ) @classmethod @@ -6030,25 +5424,22 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_GUARDRAIL_CHECKS_CONTENT_FILTER_CONFIG) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["categories"] = ( _deserialize_guardrail_checks_content_filter_category_config_list( - de, - _SCHEMA_GUARDRAIL_CHECKS_CONTENT_FILTER_CONFIG.members[ - "categories" - ], + de, members[0] ) ) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_GUARDRAIL_CHECKS_CONTENT_FILTER_CONFIG, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) if "categories" not in kwargs: kwargs["categories"] = [] return kwargs @@ -6071,14 +5462,14 @@ class GuardrailChecksPromptAttackCategoryConfig: def serialize(self, serializer: ShapeSerializer): serializer.write_struct( - _SCHEMA_GUARDRAIL_CHECKS_PROMPT_ATTACK_CATEGORY_CONFIG, self + hydrate(_SCHEMA_GUARDRAIL_CHECKS_PROMPT_ATTACK_CATEGORY_CONFIG), self ) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_string( - _SCHEMA_GUARDRAIL_CHECKS_PROMPT_ATTACK_CATEGORY_CONFIG.members["category"], - self.category, - ) + members = hydrate( + _SCHEMA_GUARDRAIL_CHECKS_PROMPT_ATTACK_CATEGORY_CONFIG + ).members_by_index + serializer.write_string(members[0], self.category) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -6087,24 +5478,20 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_GUARDRAIL_CHECKS_PROMPT_ATTACK_CATEGORY_CONFIG) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["category"] = GuardrailChecksPromptAttackCategory( - de.read_string( - _SCHEMA_GUARDRAIL_CHECKS_PROMPT_ATTACK_CATEGORY_CONFIG.members[ - "category" - ] - ) + de.read_string(members[0]) ) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_GUARDRAIL_CHECKS_PROMPT_ATTACK_CATEGORY_CONFIG, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) if "category" not in kwargs: kwargs["category"] = GuardrailChecksPromptAttackCategory._corrected("") return kwargs @@ -6115,7 +5502,7 @@ def _serialize_guardrail_checks_prompt_attack_category_config_list( schema: Schema, value: list[GuardrailChecksPromptAttackCategoryConfig], ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_struct(member_schema, e) @@ -6148,13 +5535,16 @@ class GuardrailChecksPromptAttackConfig: """The prompt attack categories to evaluate.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_GUARDRAIL_CHECKS_PROMPT_ATTACK_CONFIG, self) + serializer.write_struct( + hydrate(_SCHEMA_GUARDRAIL_CHECKS_PROMPT_ATTACK_CONFIG), self + ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate( + _SCHEMA_GUARDRAIL_CHECKS_PROMPT_ATTACK_CONFIG + ).members_by_index _serialize_guardrail_checks_prompt_attack_category_config_list( - serializer, - _SCHEMA_GUARDRAIL_CHECKS_PROMPT_ATTACK_CONFIG.members["categories"], - self.categories, + serializer, members[0], self.categories ) @classmethod @@ -6164,25 +5554,22 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_GUARDRAIL_CHECKS_PROMPT_ATTACK_CONFIG) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["categories"] = ( _deserialize_guardrail_checks_prompt_attack_category_config_list( - de, - _SCHEMA_GUARDRAIL_CHECKS_PROMPT_ATTACK_CONFIG.members[ - "categories" - ], + de, members[0] ) ) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_GUARDRAIL_CHECKS_PROMPT_ATTACK_CONFIG, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) if "categories" not in kwargs: kwargs["categories"] = [] return kwargs @@ -6236,16 +5623,14 @@ class GuardrailChecksSensitiveInformationEntityConfig: def serialize(self, serializer: ShapeSerializer): serializer.write_struct( - _SCHEMA_GUARDRAIL_CHECKS_SENSITIVE_INFORMATION_ENTITY_CONFIG, self + hydrate(_SCHEMA_GUARDRAIL_CHECKS_SENSITIVE_INFORMATION_ENTITY_CONFIG), self ) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_string( - _SCHEMA_GUARDRAIL_CHECKS_SENSITIVE_INFORMATION_ENTITY_CONFIG.members[ - "type" - ], - self.type, - ) + members = hydrate( + _SCHEMA_GUARDRAIL_CHECKS_SENSITIVE_INFORMATION_ENTITY_CONFIG + ).members_by_index + serializer.write_string(members[0], self.type) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -6254,25 +5639,20 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_GUARDRAIL_CHECKS_SENSITIVE_INFORMATION_ENTITY_CONFIG) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["type"] = GuardrailChecksSensitiveInformationEntityType( - de.read_string( - _SCHEMA_GUARDRAIL_CHECKS_SENSITIVE_INFORMATION_ENTITY_CONFIG.members[ - "type" - ] - ) + de.read_string(members[0]) ) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_GUARDRAIL_CHECKS_SENSITIVE_INFORMATION_ENTITY_CONFIG, - consumer=_consumer, - ) + deserializer.read_struct(schema, consumer=_consumer) if "type" not in kwargs: kwargs["type"] = GuardrailChecksSensitiveInformationEntityType._corrected( "" @@ -6285,7 +5665,7 @@ def _serialize_guardrail_checks_sensitive_information_entity_config_list( schema: Schema, value: list[GuardrailChecksSensitiveInformationEntityConfig], ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_struct(member_schema, e) @@ -6321,14 +5701,15 @@ class GuardrailChecksSensitiveInformationConfig: def serialize(self, serializer: ShapeSerializer): serializer.write_struct( - _SCHEMA_GUARDRAIL_CHECKS_SENSITIVE_INFORMATION_CONFIG, self + hydrate(_SCHEMA_GUARDRAIL_CHECKS_SENSITIVE_INFORMATION_CONFIG), self ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate( + _SCHEMA_GUARDRAIL_CHECKS_SENSITIVE_INFORMATION_CONFIG + ).members_by_index _serialize_guardrail_checks_sensitive_information_entity_config_list( - serializer, - _SCHEMA_GUARDRAIL_CHECKS_SENSITIVE_INFORMATION_CONFIG.members["entities"], - self.entities, + serializer, members[0], self.entities ) @classmethod @@ -6338,25 +5719,22 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_GUARDRAIL_CHECKS_SENSITIVE_INFORMATION_CONFIG) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["entities"] = ( _deserialize_guardrail_checks_sensitive_information_entity_config_list( - de, - _SCHEMA_GUARDRAIL_CHECKS_SENSITIVE_INFORMATION_CONFIG.members[ - "entities" - ], + de, members[0] ) ) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_GUARDRAIL_CHECKS_SENSITIVE_INFORMATION_CONFIG, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) if "entities" not in kwargs: kwargs["entities"] = [] return kwargs @@ -6379,26 +5757,18 @@ class GuardrailChecksConfig: """The sensitive information check configuration.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_GUARDRAIL_CHECKS_CONFIG, self) + serializer.write_struct(hydrate(_SCHEMA_GUARDRAIL_CHECKS_CONFIG), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_GUARDRAIL_CHECKS_CONFIG).members_by_index if self.content_filter is not None: - serializer.write_struct( - _SCHEMA_GUARDRAIL_CHECKS_CONFIG.members["contentFilter"], - self.content_filter, - ) + serializer.write_struct(members[0], self.content_filter) if self.prompt_attack is not None: - serializer.write_struct( - _SCHEMA_GUARDRAIL_CHECKS_CONFIG.members["promptAttack"], - self.prompt_attack, - ) + serializer.write_struct(members[1], self.prompt_attack) if self.sensitive_information is not None: - serializer.write_struct( - _SCHEMA_GUARDRAIL_CHECKS_CONFIG.members["sensitiveInformation"], - self.sensitive_information, - ) + serializer.write_struct(members[2], self.sensitive_information) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -6407,9 +5777,11 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_GUARDRAIL_CHECKS_CONFIG) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["content_filter"] = ( GuardrailChecksContentFilterConfig.deserialize(de) @@ -6426,9 +5798,9 @@ def _consumer(schema: Schema, de: ShapeDeserializer) -> None: ) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_GUARDRAIL_CHECKS_CONFIG, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -6439,20 +5811,16 @@ class GuardrailChecksContentBlockText: value: str def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_GUARDRAIL_CHECKS_CONTENT_BLOCK, self) + serializer.write_struct(hydrate(_SCHEMA_GUARDRAIL_CHECKS_CONTENT_BLOCK), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_string( - _SCHEMA_GUARDRAIL_CHECKS_CONTENT_BLOCK.members["text"], self.value - ) + members = hydrate(_SCHEMA_GUARDRAIL_CHECKS_CONTENT_BLOCK).members_by_index + serializer.write_string(members[0], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: - return cls( - value=deserializer.read_string( - _SCHEMA_GUARDRAIL_CHECKS_CONTENT_BLOCK.members["text"] - ) - ) + members = hydrate(_SCHEMA_GUARDRAIL_CHECKS_CONTENT_BLOCK).members_by_index + return cls(value=deserializer.read_string(members[0])) @dataclass @@ -6492,7 +5860,9 @@ def deserialize( self, deserializer: ShapeDeserializer ) -> GuardrailChecksContentBlock: self._result = None - deserializer.read_struct(_SCHEMA_GUARDRAIL_CHECKS_CONTENT_BLOCK, self._consumer) + deserializer.read_struct( + hydrate(_SCHEMA_GUARDRAIL_CHECKS_CONTENT_BLOCK), self._consumer + ) if self._result is None: raise SerializationError( @@ -6524,7 +5894,7 @@ def _serialize_guardrail_checks_content_block_list( schema: Schema, value: list[GuardrailChecksContentBlock], ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_struct(member_schema, e) @@ -6568,16 +5938,13 @@ class GuardrailChecksMessage: """The content blocks for the message.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_GUARDRAIL_CHECKS_MESSAGE, self) + serializer.write_struct(hydrate(_SCHEMA_GUARDRAIL_CHECKS_MESSAGE), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_string( - _SCHEMA_GUARDRAIL_CHECKS_MESSAGE.members["role"], self.role - ) + members = hydrate(_SCHEMA_GUARDRAIL_CHECKS_MESSAGE).members_by_index + serializer.write_string(members[0], self.role) _serialize_guardrail_checks_content_block_list( - serializer, - _SCHEMA_GUARDRAIL_CHECKS_MESSAGE.members["content"], - self.content, + serializer, members[1], self.content ) @classmethod @@ -6587,25 +5954,23 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_GUARDRAIL_CHECKS_MESSAGE) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["role"] = GuardrailChecksRole( - de.read_string(_SCHEMA_GUARDRAIL_CHECKS_MESSAGE.members["role"]) - ) + kwargs["role"] = GuardrailChecksRole(de.read_string(members[0])) case 1: kwargs["content"] = ( - _deserialize_guardrail_checks_content_block_list( - de, _SCHEMA_GUARDRAIL_CHECKS_MESSAGE.members["content"] - ) + _deserialize_guardrail_checks_content_block_list(de, members[1]) ) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_GUARDRAIL_CHECKS_MESSAGE, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) if "role" not in kwargs: kwargs["role"] = GuardrailChecksRole._corrected("") if "content" not in kwargs: @@ -6616,7 +5981,7 @@ def _consumer(schema: Schema, de: ShapeDeserializer) -> None: def _serialize_guardrail_checks_message_list( serializer: ShapeSerializer, schema: Schema, value: list[GuardrailChecksMessage] ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_struct(member_schema, e) @@ -6655,20 +6020,17 @@ class InvokeGuardrailChecksInput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_INVOKE_GUARDRAIL_CHECKS_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_INVOKE_GUARDRAIL_CHECKS_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_INVOKE_GUARDRAIL_CHECKS_INPUT).members_by_index if self.messages is not None: _serialize_guardrail_checks_message_list( - serializer, - _SCHEMA_INVOKE_GUARDRAIL_CHECKS_INPUT.members["messages"], - self.messages, + serializer, members[0], self.messages ) if self.checks is not None: - serializer.write_struct( - _SCHEMA_INVOKE_GUARDRAIL_CHECKS_INPUT.members["checks"], self.checks - ) + serializer.write_struct(members[1], self.checks) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -6677,23 +6039,23 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_INVOKE_GUARDRAIL_CHECKS_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["messages"] = _deserialize_guardrail_checks_message_list( - de, _SCHEMA_INVOKE_GUARDRAIL_CHECKS_INPUT.members["messages"] + de, members[0] ) case 1: kwargs["checks"] = GuardrailChecksConfig.deserialize(de) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_INVOKE_GUARDRAIL_CHECKS_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -6712,20 +6074,15 @@ class GuardrailChecksContentFilterResultEntry: def serialize(self, serializer: ShapeSerializer): serializer.write_struct( - _SCHEMA_GUARDRAIL_CHECKS_CONTENT_FILTER_RESULT_ENTRY, self + hydrate(_SCHEMA_GUARDRAIL_CHECKS_CONTENT_FILTER_RESULT_ENTRY), self ) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_string( - _SCHEMA_GUARDRAIL_CHECKS_CONTENT_FILTER_RESULT_ENTRY.members["category"], - self.category, - ) - serializer.write_double( - _SCHEMA_GUARDRAIL_CHECKS_CONTENT_FILTER_RESULT_ENTRY.members[ - "severityScore" - ], - self.severity_score, - ) + members = hydrate( + _SCHEMA_GUARDRAIL_CHECKS_CONTENT_FILTER_RESULT_ENTRY + ).members_by_index + serializer.write_string(members[0], self.category) + serializer.write_double(members[1], self.severity_score) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -6734,31 +6091,23 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_GUARDRAIL_CHECKS_CONTENT_FILTER_RESULT_ENTRY) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["category"] = GuardrailChecksContentFilterCategory( - de.read_string( - _SCHEMA_GUARDRAIL_CHECKS_CONTENT_FILTER_RESULT_ENTRY.members[ - "category" - ] - ) + de.read_string(members[0]) ) case 1: - kwargs["severity_score"] = de.read_double( - _SCHEMA_GUARDRAIL_CHECKS_CONTENT_FILTER_RESULT_ENTRY.members[ - "severityScore" - ] - ) + kwargs["severity_score"] = de.read_double(members[1]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_GUARDRAIL_CHECKS_CONTENT_FILTER_RESULT_ENTRY, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) if "category" not in kwargs: kwargs["category"] = GuardrailChecksContentFilterCategory._corrected("") if "severity_score" not in kwargs: @@ -6771,7 +6120,7 @@ def _serialize_guardrail_checks_content_filter_result_list( schema: Schema, value: list[GuardrailChecksContentFilterResultEntry], ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_struct(member_schema, e) @@ -6801,13 +6150,16 @@ class GuardrailChecksContentFilterResult: """The per-category content filter results.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_GUARDRAIL_CHECKS_CONTENT_FILTER_RESULT, self) + serializer.write_struct( + hydrate(_SCHEMA_GUARDRAIL_CHECKS_CONTENT_FILTER_RESULT), self + ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate( + _SCHEMA_GUARDRAIL_CHECKS_CONTENT_FILTER_RESULT + ).members_by_index _serialize_guardrail_checks_content_filter_result_list( - serializer, - _SCHEMA_GUARDRAIL_CHECKS_CONTENT_FILTER_RESULT.members["results"], - self.results, + serializer, members[0], self.results ) @classmethod @@ -6817,25 +6169,22 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_GUARDRAIL_CHECKS_CONTENT_FILTER_RESULT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["results"] = ( _deserialize_guardrail_checks_content_filter_result_list( - de, - _SCHEMA_GUARDRAIL_CHECKS_CONTENT_FILTER_RESULT.members[ - "results" - ], + de, members[0] ) ) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_GUARDRAIL_CHECKS_CONTENT_FILTER_RESULT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) if "results" not in kwargs: kwargs["results"] = [] return kwargs @@ -6856,20 +6205,15 @@ class GuardrailChecksPromptAttackResultEntry: def serialize(self, serializer: ShapeSerializer): serializer.write_struct( - _SCHEMA_GUARDRAIL_CHECKS_PROMPT_ATTACK_RESULT_ENTRY, self + hydrate(_SCHEMA_GUARDRAIL_CHECKS_PROMPT_ATTACK_RESULT_ENTRY), self ) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_string( - _SCHEMA_GUARDRAIL_CHECKS_PROMPT_ATTACK_RESULT_ENTRY.members["category"], - self.category, - ) - serializer.write_double( - _SCHEMA_GUARDRAIL_CHECKS_PROMPT_ATTACK_RESULT_ENTRY.members[ - "severityScore" - ], - self.severity_score, - ) + members = hydrate( + _SCHEMA_GUARDRAIL_CHECKS_PROMPT_ATTACK_RESULT_ENTRY + ).members_by_index + serializer.write_string(members[0], self.category) + serializer.write_double(members[1], self.severity_score) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -6878,31 +6222,23 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_GUARDRAIL_CHECKS_PROMPT_ATTACK_RESULT_ENTRY) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["category"] = GuardrailChecksPromptAttackCategory( - de.read_string( - _SCHEMA_GUARDRAIL_CHECKS_PROMPT_ATTACK_RESULT_ENTRY.members[ - "category" - ] - ) + de.read_string(members[0]) ) case 1: - kwargs["severity_score"] = de.read_double( - _SCHEMA_GUARDRAIL_CHECKS_PROMPT_ATTACK_RESULT_ENTRY.members[ - "severityScore" - ] - ) + kwargs["severity_score"] = de.read_double(members[1]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_GUARDRAIL_CHECKS_PROMPT_ATTACK_RESULT_ENTRY, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) if "category" not in kwargs: kwargs["category"] = GuardrailChecksPromptAttackCategory._corrected("") if "severity_score" not in kwargs: @@ -6915,7 +6251,7 @@ def _serialize_guardrail_checks_prompt_attack_result_list( schema: Schema, value: list[GuardrailChecksPromptAttackResultEntry], ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_struct(member_schema, e) @@ -6945,13 +6281,16 @@ class GuardrailChecksPromptAttackResult: """The per-category prompt attack results.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_GUARDRAIL_CHECKS_PROMPT_ATTACK_RESULT, self) + serializer.write_struct( + hydrate(_SCHEMA_GUARDRAIL_CHECKS_PROMPT_ATTACK_RESULT), self + ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate( + _SCHEMA_GUARDRAIL_CHECKS_PROMPT_ATTACK_RESULT + ).members_by_index _serialize_guardrail_checks_prompt_attack_result_list( - serializer, - _SCHEMA_GUARDRAIL_CHECKS_PROMPT_ATTACK_RESULT.members["results"], - self.results, + serializer, members[0], self.results ) @classmethod @@ -6961,25 +6300,22 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_GUARDRAIL_CHECKS_PROMPT_ATTACK_RESULT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["results"] = ( _deserialize_guardrail_checks_prompt_attack_result_list( - de, - _SCHEMA_GUARDRAIL_CHECKS_PROMPT_ATTACK_RESULT.members[ - "results" - ], + de, members[0] ) ) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_GUARDRAIL_CHECKS_PROMPT_ATTACK_RESULT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) if "results" not in kwargs: kwargs["results"] = [] return kwargs @@ -7027,44 +6363,19 @@ class GuardrailChecksSensitiveInformationResultEntry: def serialize(self, serializer: ShapeSerializer): serializer.write_struct( - _SCHEMA_GUARDRAIL_CHECKS_SENSITIVE_INFORMATION_RESULT_ENTRY, self + hydrate(_SCHEMA_GUARDRAIL_CHECKS_SENSITIVE_INFORMATION_RESULT_ENTRY), self ) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_string( - _SCHEMA_GUARDRAIL_CHECKS_SENSITIVE_INFORMATION_RESULT_ENTRY.members["type"], - self.type, - ) - serializer.write_double( - _SCHEMA_GUARDRAIL_CHECKS_SENSITIVE_INFORMATION_RESULT_ENTRY.members[ - "confidenceScore" - ], - self.confidence_score, - ) - serializer.write_integer( - _SCHEMA_GUARDRAIL_CHECKS_SENSITIVE_INFORMATION_RESULT_ENTRY.members[ - "beginOffset" - ], - self.begin_offset, - ) - serializer.write_integer( - _SCHEMA_GUARDRAIL_CHECKS_SENSITIVE_INFORMATION_RESULT_ENTRY.members[ - "endOffset" - ], - self.end_offset, - ) - serializer.write_integer( - _SCHEMA_GUARDRAIL_CHECKS_SENSITIVE_INFORMATION_RESULT_ENTRY.members[ - "messageIndex" - ], - self.message_index, - ) - serializer.write_integer( - _SCHEMA_GUARDRAIL_CHECKS_SENSITIVE_INFORMATION_RESULT_ENTRY.members[ - "contentIndex" - ], - self.content_index, - ) + members = hydrate( + _SCHEMA_GUARDRAIL_CHECKS_SENSITIVE_INFORMATION_RESULT_ENTRY + ).members_by_index + serializer.write_string(members[0], self.type) + serializer.write_double(members[1], self.confidence_score) + serializer.write_integer(members[2], self.begin_offset) + serializer.write_integer(members[3], self.end_offset) + serializer.write_integer(members[4], self.message_index) + serializer.write_integer(members[5], self.content_index) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -7073,60 +6384,35 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_GUARDRAIL_CHECKS_SENSITIVE_INFORMATION_RESULT_ENTRY) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["type"] = GuardrailChecksSensitiveInformationEntityType( - de.read_string( - _SCHEMA_GUARDRAIL_CHECKS_SENSITIVE_INFORMATION_RESULT_ENTRY.members[ - "type" - ] - ) + de.read_string(members[0]) ) case 1: - kwargs["confidence_score"] = de.read_double( - _SCHEMA_GUARDRAIL_CHECKS_SENSITIVE_INFORMATION_RESULT_ENTRY.members[ - "confidenceScore" - ] - ) + kwargs["confidence_score"] = de.read_double(members[1]) case 2: - kwargs["begin_offset"] = de.read_integer( - _SCHEMA_GUARDRAIL_CHECKS_SENSITIVE_INFORMATION_RESULT_ENTRY.members[ - "beginOffset" - ] - ) + kwargs["begin_offset"] = de.read_integer(members[2]) case 3: - kwargs["end_offset"] = de.read_integer( - _SCHEMA_GUARDRAIL_CHECKS_SENSITIVE_INFORMATION_RESULT_ENTRY.members[ - "endOffset" - ] - ) + kwargs["end_offset"] = de.read_integer(members[3]) case 4: - kwargs["message_index"] = de.read_integer( - _SCHEMA_GUARDRAIL_CHECKS_SENSITIVE_INFORMATION_RESULT_ENTRY.members[ - "messageIndex" - ] - ) + kwargs["message_index"] = de.read_integer(members[4]) case 5: - kwargs["content_index"] = de.read_integer( - _SCHEMA_GUARDRAIL_CHECKS_SENSITIVE_INFORMATION_RESULT_ENTRY.members[ - "contentIndex" - ] - ) + kwargs["content_index"] = de.read_integer(members[5]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_GUARDRAIL_CHECKS_SENSITIVE_INFORMATION_RESULT_ENTRY, - consumer=_consumer, - ) + deserializer.read_struct(schema, consumer=_consumer) if "type" not in kwargs: kwargs["type"] = GuardrailChecksSensitiveInformationEntityType._corrected( "" @@ -7149,7 +6435,7 @@ def _serialize_guardrail_checks_sensitive_information_result_list( schema: Schema, value: list[GuardrailChecksSensitiveInformationResultEntry], ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_struct(member_schema, e) @@ -7186,22 +6472,18 @@ class GuardrailChecksSensitiveInformationResult: def serialize(self, serializer: ShapeSerializer): serializer.write_struct( - _SCHEMA_GUARDRAIL_CHECKS_SENSITIVE_INFORMATION_RESULT, self + hydrate(_SCHEMA_GUARDRAIL_CHECKS_SENSITIVE_INFORMATION_RESULT), self ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate( + _SCHEMA_GUARDRAIL_CHECKS_SENSITIVE_INFORMATION_RESULT + ).members_by_index _serialize_guardrail_checks_sensitive_information_result_list( - serializer, - _SCHEMA_GUARDRAIL_CHECKS_SENSITIVE_INFORMATION_RESULT.members["results"], - self.results, + serializer, members[0], self.results ) if self.truncated is not None: - serializer.write_boolean( - _SCHEMA_GUARDRAIL_CHECKS_SENSITIVE_INFORMATION_RESULT.members[ - "truncated" - ], - self.truncated, - ) + serializer.write_boolean(members[1], self.truncated) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -7210,32 +6492,25 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_GUARDRAIL_CHECKS_SENSITIVE_INFORMATION_RESULT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["results"] = ( _deserialize_guardrail_checks_sensitive_information_result_list( - de, - _SCHEMA_GUARDRAIL_CHECKS_SENSITIVE_INFORMATION_RESULT.members[ - "results" - ], + de, members[0] ) ) case 1: - kwargs["truncated"] = de.read_boolean( - _SCHEMA_GUARDRAIL_CHECKS_SENSITIVE_INFORMATION_RESULT.members[ - "truncated" - ] - ) + kwargs["truncated"] = de.read_boolean(members[1]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_GUARDRAIL_CHECKS_SENSITIVE_INFORMATION_RESULT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) if "results" not in kwargs: kwargs["results"] = [] return kwargs @@ -7258,26 +6533,18 @@ class GuardrailChecksResults: """The sensitive information check results.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_GUARDRAIL_CHECKS_RESULTS, self) + serializer.write_struct(hydrate(_SCHEMA_GUARDRAIL_CHECKS_RESULTS), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_GUARDRAIL_CHECKS_RESULTS).members_by_index if self.content_filter is not None: - serializer.write_struct( - _SCHEMA_GUARDRAIL_CHECKS_RESULTS.members["contentFilter"], - self.content_filter, - ) + serializer.write_struct(members[0], self.content_filter) if self.prompt_attack is not None: - serializer.write_struct( - _SCHEMA_GUARDRAIL_CHECKS_RESULTS.members["promptAttack"], - self.prompt_attack, - ) + serializer.write_struct(members[1], self.prompt_attack) if self.sensitive_information is not None: - serializer.write_struct( - _SCHEMA_GUARDRAIL_CHECKS_RESULTS.members["sensitiveInformation"], - self.sensitive_information, - ) + serializer.write_struct(members[2], self.sensitive_information) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -7286,9 +6553,11 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_GUARDRAIL_CHECKS_RESULTS) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["content_filter"] = ( GuardrailChecksContentFilterResult.deserialize(de) @@ -7305,9 +6574,9 @@ def _consumer(schema: Schema, de: ShapeDeserializer) -> None: ) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_GUARDRAIL_CHECKS_RESULTS, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @classmethod @@ -7323,13 +6592,15 @@ class GuardrailChecksContentFilterUsage: """The number of text units consumed by the content filter check.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_GUARDRAIL_CHECKS_CONTENT_FILTER_USAGE, self) + serializer.write_struct( + hydrate(_SCHEMA_GUARDRAIL_CHECKS_CONTENT_FILTER_USAGE), self + ) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_integer( - _SCHEMA_GUARDRAIL_CHECKS_CONTENT_FILTER_USAGE.members["textUnits"], - self.text_units, - ) + members = hydrate( + _SCHEMA_GUARDRAIL_CHECKS_CONTENT_FILTER_USAGE + ).members_by_index + serializer.write_integer(members[0], self.text_units) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -7338,22 +6609,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_GUARDRAIL_CHECKS_CONTENT_FILTER_USAGE) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["text_units"] = de.read_integer( - _SCHEMA_GUARDRAIL_CHECKS_CONTENT_FILTER_USAGE.members[ - "textUnits" - ] - ) + kwargs["text_units"] = de.read_integer(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_GUARDRAIL_CHECKS_CONTENT_FILTER_USAGE, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) if "text_units" not in kwargs: kwargs["text_units"] = 0 return kwargs @@ -7367,13 +6634,13 @@ class GuardrailChecksPromptAttackUsage: """The number of text units consumed by the prompt attack check.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_GUARDRAIL_CHECKS_PROMPT_ATTACK_USAGE, self) + serializer.write_struct( + hydrate(_SCHEMA_GUARDRAIL_CHECKS_PROMPT_ATTACK_USAGE), self + ) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_integer( - _SCHEMA_GUARDRAIL_CHECKS_PROMPT_ATTACK_USAGE.members["textUnits"], - self.text_units, - ) + members = hydrate(_SCHEMA_GUARDRAIL_CHECKS_PROMPT_ATTACK_USAGE).members_by_index + serializer.write_integer(members[0], self.text_units) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -7382,22 +6649,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_GUARDRAIL_CHECKS_PROMPT_ATTACK_USAGE) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["text_units"] = de.read_integer( - _SCHEMA_GUARDRAIL_CHECKS_PROMPT_ATTACK_USAGE.members[ - "textUnits" - ] - ) + kwargs["text_units"] = de.read_integer(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_GUARDRAIL_CHECKS_PROMPT_ATTACK_USAGE, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) if "text_units" not in kwargs: kwargs["text_units"] = 0 return kwargs @@ -7412,14 +6675,14 @@ class GuardrailChecksSensitiveInformationUsage: def serialize(self, serializer: ShapeSerializer): serializer.write_struct( - _SCHEMA_GUARDRAIL_CHECKS_SENSITIVE_INFORMATION_USAGE, self + hydrate(_SCHEMA_GUARDRAIL_CHECKS_SENSITIVE_INFORMATION_USAGE), self ) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_integer( - _SCHEMA_GUARDRAIL_CHECKS_SENSITIVE_INFORMATION_USAGE.members["textUnits"], - self.text_units, - ) + members = hydrate( + _SCHEMA_GUARDRAIL_CHECKS_SENSITIVE_INFORMATION_USAGE + ).members_by_index + serializer.write_integer(members[0], self.text_units) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -7428,22 +6691,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_GUARDRAIL_CHECKS_SENSITIVE_INFORMATION_USAGE) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["text_units"] = de.read_integer( - _SCHEMA_GUARDRAIL_CHECKS_SENSITIVE_INFORMATION_USAGE.members[ - "textUnits" - ] - ) + kwargs["text_units"] = de.read_integer(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_GUARDRAIL_CHECKS_SENSITIVE_INFORMATION_USAGE, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) if "text_units" not in kwargs: kwargs["text_units"] = 0 return kwargs @@ -7466,26 +6725,18 @@ class GuardrailChecksUsageResults: """The text unit usage for the sensitive information check.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_GUARDRAIL_CHECKS_USAGE_RESULTS, self) + serializer.write_struct(hydrate(_SCHEMA_GUARDRAIL_CHECKS_USAGE_RESULTS), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_GUARDRAIL_CHECKS_USAGE_RESULTS).members_by_index if self.content_filter is not None: - serializer.write_struct( - _SCHEMA_GUARDRAIL_CHECKS_USAGE_RESULTS.members["contentFilter"], - self.content_filter, - ) + serializer.write_struct(members[0], self.content_filter) if self.prompt_attack is not None: - serializer.write_struct( - _SCHEMA_GUARDRAIL_CHECKS_USAGE_RESULTS.members["promptAttack"], - self.prompt_attack, - ) + serializer.write_struct(members[1], self.prompt_attack) if self.sensitive_information is not None: - serializer.write_struct( - _SCHEMA_GUARDRAIL_CHECKS_USAGE_RESULTS.members["sensitiveInformation"], - self.sensitive_information, - ) + serializer.write_struct(members[2], self.sensitive_information) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -7494,9 +6745,11 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_GUARDRAIL_CHECKS_USAGE_RESULTS) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["content_filter"] = ( GuardrailChecksContentFilterUsage.deserialize(de) @@ -7513,11 +6766,9 @@ def _consumer(schema: Schema, de: ShapeDeserializer) -> None: ) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_GUARDRAIL_CHECKS_USAGE_RESULTS, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @classmethod @@ -7546,15 +6797,12 @@ class InvokeGuardrailChecksOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_INVOKE_GUARDRAIL_CHECKS_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_INVOKE_GUARDRAIL_CHECKS_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_struct( - _SCHEMA_INVOKE_GUARDRAIL_CHECKS_OUTPUT.members["results"], self.results - ) - serializer.write_struct( - _SCHEMA_INVOKE_GUARDRAIL_CHECKS_OUTPUT.members["usage"], self.usage - ) + members = hydrate(_SCHEMA_INVOKE_GUARDRAIL_CHECKS_OUTPUT).members_by_index + serializer.write_struct(members[0], self.results) + serializer.write_struct(members[1], self.usage) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -7563,9 +6811,11 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_INVOKE_GUARDRAIL_CHECKS_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["results"] = GuardrailChecksResults.deserialize(de) @@ -7573,11 +6823,9 @@ def _consumer(schema: Schema, de: ShapeDeserializer) -> None: kwargs["usage"] = GuardrailChecksUsageResults.deserialize(de) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_INVOKE_GUARDRAIL_CHECKS_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) if "results" not in kwargs: kwargs["results"] = GuardrailChecksResults._smithy_default() if "usage" not in kwargs: @@ -7588,9 +6836,7 @@ def _consumer(schema: Schema, de: ShapeDeserializer) -> None: INVOKE_GUARDRAIL_CHECKS = APIOperation( input=InvokeGuardrailChecksInput, output=InvokeGuardrailChecksOutput, - schema=_SCHEMA_INVOKE_GUARDRAIL_CHECKS, - input_schema=_SCHEMA_INVOKE_GUARDRAIL_CHECKS_INPUT, - output_schema=_SCHEMA_INVOKE_GUARDRAIL_CHECKS_OUTPUT, + static_schema=_SCHEMA_INVOKE_GUARDRAIL_CHECKS, error_registry=TypeRegistry( { ShapeID( @@ -7614,13 +6860,6 @@ def _consumer(schema: Schema, de: ShapeDeserializer) -> None: ShapeID("aws.auth#sigv4"), ShapeID("smithy.api#httpBearerAuth"), ], - error_schemas=[ - _SCHEMA_ACCESS_DENIED_EXCEPTION, - _SCHEMA_INTERNAL_SERVER_EXCEPTION, - _SCHEMA_SERVICE_UNAVAILABLE_EXCEPTION, - _SCHEMA_THROTTLING_EXCEPTION, - _SCHEMA_VALIDATION_EXCEPTION, - ], ) @@ -7648,20 +6887,13 @@ class GuardrailConfiguration: """The trace behavior for the guardrail.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_GUARDRAIL_CONFIGURATION, self) + serializer.write_struct(hydrate(_SCHEMA_GUARDRAIL_CONFIGURATION), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_string( - _SCHEMA_GUARDRAIL_CONFIGURATION.members["guardrailIdentifier"], - self.guardrail_identifier, - ) - serializer.write_string( - _SCHEMA_GUARDRAIL_CONFIGURATION.members["guardrailVersion"], - self.guardrail_version, - ) - serializer.write_string( - _SCHEMA_GUARDRAIL_CONFIGURATION.members["trace"], self.trace - ) + members = hydrate(_SCHEMA_GUARDRAIL_CONFIGURATION).members_by_index + serializer.write_string(members[0], self.guardrail_identifier) + serializer.write_string(members[1], self.guardrail_version) + serializer.write_string(members[2], self.trace) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -7670,35 +6902,31 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_GUARDRAIL_CONFIGURATION) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["guardrail_identifier"] = de.read_string( - _SCHEMA_GUARDRAIL_CONFIGURATION.members["guardrailIdentifier"] - ) + kwargs["guardrail_identifier"] = de.read_string(members[0]) case 1: - kwargs["guardrail_version"] = de.read_string( - _SCHEMA_GUARDRAIL_CONFIGURATION.members["guardrailVersion"] - ) + kwargs["guardrail_version"] = de.read_string(members[1]) case 2: - kwargs["trace"] = GuardrailTrace( - de.read_string(_SCHEMA_GUARDRAIL_CONFIGURATION.members["trace"]) - ) + kwargs["trace"] = GuardrailTrace(de.read_string(members[2])) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_GUARDRAIL_CONFIGURATION, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs def _serialize_non_empty_string_list( serializer: ShapeSerializer, schema: Schema, value: list[str] ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_string(member_schema, e) @@ -7708,7 +6936,7 @@ def _deserialize_non_empty_string_list( deserializer: ShapeDeserializer, schema: Schema ) -> list[str]: result: list[str] = [] - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] def _read_value(d: ShapeDeserializer): if d.is_null(): @@ -7776,29 +7004,22 @@ class InferenceConfiguration: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_INFERENCE_CONFIGURATION, self) + serializer.write_struct(hydrate(_SCHEMA_INFERENCE_CONFIGURATION), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_INFERENCE_CONFIGURATION).members_by_index if self.max_tokens is not None: - serializer.write_integer( - _SCHEMA_INFERENCE_CONFIGURATION.members["maxTokens"], self.max_tokens - ) + serializer.write_integer(members[0], self.max_tokens) if self.temperature is not None: - serializer.write_float( - _SCHEMA_INFERENCE_CONFIGURATION.members["temperature"], self.temperature - ) + serializer.write_float(members[1], self.temperature) if self.top_p is not None: - serializer.write_float( - _SCHEMA_INFERENCE_CONFIGURATION.members["topP"], self.top_p - ) + serializer.write_float(members[2], self.top_p) if self.stop_sequences is not None: _serialize_non_empty_string_list( - serializer, - _SCHEMA_INFERENCE_CONFIGURATION.members["stopSequences"], - self.stop_sequences, + serializer, members[3], self.stop_sequences ) @classmethod @@ -7808,33 +7029,29 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_INFERENCE_CONFIGURATION) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["max_tokens"] = de.read_integer( - _SCHEMA_INFERENCE_CONFIGURATION.members["maxTokens"] - ) + kwargs["max_tokens"] = de.read_integer(members[0]) case 1: - kwargs["temperature"] = de.read_float( - _SCHEMA_INFERENCE_CONFIGURATION.members["temperature"] - ) + kwargs["temperature"] = de.read_float(members[1]) case 2: - kwargs["top_p"] = de.read_float( - _SCHEMA_INFERENCE_CONFIGURATION.members["topP"] - ) + kwargs["top_p"] = de.read_float(members[2]) case 3: kwargs["stop_sequences"] = _deserialize_non_empty_string_list( - de, _SCHEMA_INFERENCE_CONFIGURATION.members["stopSequences"] + de, members[3] ) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_INFERENCE_CONFIGURATION, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -7849,13 +7066,12 @@ class ErrorBlock: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_ERROR_BLOCK, self) + serializer.write_struct(hydrate(_SCHEMA_ERROR_BLOCK), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_ERROR_BLOCK).members_by_index if self.message is not None: - serializer.write_string( - _SCHEMA_ERROR_BLOCK.members["message"], self.message - ) + serializer.write_string(members[0], self.message) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -7864,18 +7080,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_ERROR_BLOCK) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["message"] = de.read_string( - _SCHEMA_ERROR_BLOCK.members["message"] - ) + kwargs["message"] = de.read_string(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_ERROR_BLOCK, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -7911,14 +7127,13 @@ class S3Location: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_S3_LOCATION, self) + serializer.write_struct(hydrate(_SCHEMA_S3_LOCATION), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_string(_SCHEMA_S3_LOCATION.members["uri"], self.uri) + members = hydrate(_SCHEMA_S3_LOCATION).members_by_index + serializer.write_string(members[0], self.uri) if self.bucket_owner is not None: - serializer.write_string( - _SCHEMA_S3_LOCATION.members["bucketOwner"], self.bucket_owner - ) + serializer.write_string(members[1], self.bucket_owner) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -7927,21 +7142,21 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_S3_LOCATION) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["uri"] = de.read_string(_SCHEMA_S3_LOCATION.members["uri"]) + kwargs["uri"] = de.read_string(members[0]) case 1: - kwargs["bucket_owner"] = de.read_string( - _SCHEMA_S3_LOCATION.members["bucketOwner"] - ) + kwargs["bucket_owner"] = de.read_string(members[1]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_S3_LOCATION, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) if "uri" not in kwargs: kwargs["uri"] = "" return kwargs @@ -7954,14 +7169,16 @@ class AudioSourceBytes: value: bytes def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_AUDIO_SOURCE, self) + serializer.write_struct(hydrate(_SCHEMA_AUDIO_SOURCE), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_blob(_SCHEMA_AUDIO_SOURCE.members["bytes"], self.value) + members = hydrate(_SCHEMA_AUDIO_SOURCE).members_by_index + serializer.write_blob(members[0], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: - return cls(value=deserializer.read_blob(_SCHEMA_AUDIO_SOURCE.members["bytes"])) + members = hydrate(_SCHEMA_AUDIO_SOURCE).members_by_index + return cls(value=deserializer.read_blob(members[0])) @dataclass @@ -7975,10 +7192,11 @@ class AudioSourceS3Location: value: S3Location def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_AUDIO_SOURCE, self) + serializer.write_struct(hydrate(_SCHEMA_AUDIO_SOURCE), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_AUDIO_SOURCE.members["s3Location"], self.value) + members = hydrate(_SCHEMA_AUDIO_SOURCE).members_by_index + serializer.write_struct(members[1], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -8021,7 +7239,7 @@ class _AudioSourceDeserializer: def deserialize(self, deserializer: ShapeDeserializer) -> AudioSource: self._result = None - deserializer.read_struct(_SCHEMA_AUDIO_SOURCE, self._consumer) + deserializer.read_struct(hydrate(_SCHEMA_AUDIO_SOURCE), self._consumer) if self._result is None: raise SerializationError( @@ -8075,13 +7293,14 @@ class AudioBlock: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_AUDIO_BLOCK, self) + serializer.write_struct(hydrate(_SCHEMA_AUDIO_BLOCK), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_string(_SCHEMA_AUDIO_BLOCK.members["format"], self.format) - serializer.write_struct(_SCHEMA_AUDIO_BLOCK.members["source"], self.source) + members = hydrate(_SCHEMA_AUDIO_BLOCK).members_by_index + serializer.write_string(members[0], self.format) + serializer.write_struct(members[1], self.source) if self.error is not None: - serializer.write_struct(_SCHEMA_AUDIO_BLOCK.members["error"], self.error) + serializer.write_struct(members[2], self.error) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -8090,13 +7309,13 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_AUDIO_BLOCK) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["format"] = AudioFormat( - de.read_string(_SCHEMA_AUDIO_BLOCK.members["format"]) - ) + kwargs["format"] = AudioFormat(de.read_string(members[0])) case 1: kwargs["source"] = _AudioSourceDeserializer().deserialize(de) @@ -8105,9 +7324,9 @@ def _consumer(schema: Schema, de: ShapeDeserializer) -> None: kwargs["error"] = ErrorBlock.deserialize(de) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_AUDIO_BLOCK, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) if "format" not in kwargs: kwargs["format"] = AudioFormat._corrected("") if "source" not in kwargs: @@ -8144,12 +7363,13 @@ class CachePointBlock: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_CACHE_POINT_BLOCK, self) + serializer.write_struct(hydrate(_SCHEMA_CACHE_POINT_BLOCK), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_string(_SCHEMA_CACHE_POINT_BLOCK.members["type"], self.type) + members = hydrate(_SCHEMA_CACHE_POINT_BLOCK).members_by_index + serializer.write_string(members[0], self.type) if self.ttl is not None: - serializer.write_string(_SCHEMA_CACHE_POINT_BLOCK.members["ttl"], self.ttl) + serializer.write_string(members[1], self.ttl) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -8158,23 +7378,21 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_CACHE_POINT_BLOCK) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["type"] = CachePointType( - de.read_string(_SCHEMA_CACHE_POINT_BLOCK.members["type"]) - ) + kwargs["type"] = CachePointType(de.read_string(members[0])) case 1: - kwargs["ttl"] = CacheTTL( - de.read_string(_SCHEMA_CACHE_POINT_BLOCK.members["ttl"]) - ) + kwargs["ttl"] = CacheTTL(de.read_string(members[1])) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_CACHE_POINT_BLOCK, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) if "type" not in kwargs: kwargs["type"] = CachePointType._corrected("") return kwargs @@ -8204,24 +7422,18 @@ class DocumentCharLocation: """The ending character position of the cited content within the document.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_DOCUMENT_CHAR_LOCATION, self) + serializer.write_struct(hydrate(_SCHEMA_DOCUMENT_CHAR_LOCATION), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_DOCUMENT_CHAR_LOCATION).members_by_index if self.document_index is not None: - serializer.write_integer( - _SCHEMA_DOCUMENT_CHAR_LOCATION.members["documentIndex"], - self.document_index, - ) + serializer.write_integer(members[0], self.document_index) if self.start is not None: - serializer.write_integer( - _SCHEMA_DOCUMENT_CHAR_LOCATION.members["start"], self.start - ) + serializer.write_integer(members[1], self.start) if self.end is not None: - serializer.write_integer( - _SCHEMA_DOCUMENT_CHAR_LOCATION.members["end"], self.end - ) + serializer.write_integer(members[2], self.end) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -8230,28 +7442,24 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_DOCUMENT_CHAR_LOCATION) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["document_index"] = de.read_integer( - _SCHEMA_DOCUMENT_CHAR_LOCATION.members["documentIndex"] - ) + kwargs["document_index"] = de.read_integer(members[0]) case 1: - kwargs["start"] = de.read_integer( - _SCHEMA_DOCUMENT_CHAR_LOCATION.members["start"] - ) + kwargs["start"] = de.read_integer(members[1]) case 2: - kwargs["end"] = de.read_integer( - _SCHEMA_DOCUMENT_CHAR_LOCATION.members["end"] - ) + kwargs["end"] = de.read_integer(members[2]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_DOCUMENT_CHAR_LOCATION, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -8282,24 +7490,18 @@ class DocumentChunkLocation: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_DOCUMENT_CHUNK_LOCATION, self) + serializer.write_struct(hydrate(_SCHEMA_DOCUMENT_CHUNK_LOCATION), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_DOCUMENT_CHUNK_LOCATION).members_by_index if self.document_index is not None: - serializer.write_integer( - _SCHEMA_DOCUMENT_CHUNK_LOCATION.members["documentIndex"], - self.document_index, - ) + serializer.write_integer(members[0], self.document_index) if self.start is not None: - serializer.write_integer( - _SCHEMA_DOCUMENT_CHUNK_LOCATION.members["start"], self.start - ) + serializer.write_integer(members[1], self.start) if self.end is not None: - serializer.write_integer( - _SCHEMA_DOCUMENT_CHUNK_LOCATION.members["end"], self.end - ) + serializer.write_integer(members[2], self.end) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -8308,28 +7510,24 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_DOCUMENT_CHUNK_LOCATION) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["document_index"] = de.read_integer( - _SCHEMA_DOCUMENT_CHUNK_LOCATION.members["documentIndex"] - ) + kwargs["document_index"] = de.read_integer(members[0]) case 1: - kwargs["start"] = de.read_integer( - _SCHEMA_DOCUMENT_CHUNK_LOCATION.members["start"] - ) + kwargs["start"] = de.read_integer(members[1]) case 2: - kwargs["end"] = de.read_integer( - _SCHEMA_DOCUMENT_CHUNK_LOCATION.members["end"] - ) + kwargs["end"] = de.read_integer(members[2]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_DOCUMENT_CHUNK_LOCATION, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -8353,24 +7551,18 @@ class DocumentPageLocation: """The ending page number of the cited content within the document.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_DOCUMENT_PAGE_LOCATION, self) + serializer.write_struct(hydrate(_SCHEMA_DOCUMENT_PAGE_LOCATION), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_DOCUMENT_PAGE_LOCATION).members_by_index if self.document_index is not None: - serializer.write_integer( - _SCHEMA_DOCUMENT_PAGE_LOCATION.members["documentIndex"], - self.document_index, - ) + serializer.write_integer(members[0], self.document_index) if self.start is not None: - serializer.write_integer( - _SCHEMA_DOCUMENT_PAGE_LOCATION.members["start"], self.start - ) + serializer.write_integer(members[1], self.start) if self.end is not None: - serializer.write_integer( - _SCHEMA_DOCUMENT_PAGE_LOCATION.members["end"], self.end - ) + serializer.write_integer(members[2], self.end) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -8379,28 +7571,24 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_DOCUMENT_PAGE_LOCATION) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["document_index"] = de.read_integer( - _SCHEMA_DOCUMENT_PAGE_LOCATION.members["documentIndex"] - ) + kwargs["document_index"] = de.read_integer(members[0]) case 1: - kwargs["start"] = de.read_integer( - _SCHEMA_DOCUMENT_PAGE_LOCATION.members["start"] - ) + kwargs["start"] = de.read_integer(members[1]) case 2: - kwargs["end"] = de.read_integer( - _SCHEMA_DOCUMENT_PAGE_LOCATION.members["end"] - ) + kwargs["end"] = de.read_integer(members[2]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_DOCUMENT_PAGE_LOCATION, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -8428,24 +7616,18 @@ class SearchResultLocation: """The ending position in the content array where the cited content ends.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_SEARCH_RESULT_LOCATION, self) + serializer.write_struct(hydrate(_SCHEMA_SEARCH_RESULT_LOCATION), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_SEARCH_RESULT_LOCATION).members_by_index if self.search_result_index is not None: - serializer.write_integer( - _SCHEMA_SEARCH_RESULT_LOCATION.members["searchResultIndex"], - self.search_result_index, - ) + serializer.write_integer(members[0], self.search_result_index) if self.start is not None: - serializer.write_integer( - _SCHEMA_SEARCH_RESULT_LOCATION.members["start"], self.start - ) + serializer.write_integer(members[1], self.start) if self.end is not None: - serializer.write_integer( - _SCHEMA_SEARCH_RESULT_LOCATION.members["end"], self.end - ) + serializer.write_integer(members[2], self.end) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -8454,28 +7636,24 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_SEARCH_RESULT_LOCATION) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["search_result_index"] = de.read_integer( - _SCHEMA_SEARCH_RESULT_LOCATION.members["searchResultIndex"] - ) + kwargs["search_result_index"] = de.read_integer(members[0]) case 1: - kwargs["start"] = de.read_integer( - _SCHEMA_SEARCH_RESULT_LOCATION.members["start"] - ) + kwargs["start"] = de.read_integer(members[1]) case 2: - kwargs["end"] = de.read_integer( - _SCHEMA_SEARCH_RESULT_LOCATION.members["end"] - ) + kwargs["end"] = de.read_integer(members[2]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_SEARCH_RESULT_LOCATION, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -8493,14 +7671,15 @@ class WebLocation: """The domain that was cited when performing a web search.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_WEB_LOCATION, self) + serializer.write_struct(hydrate(_SCHEMA_WEB_LOCATION), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_WEB_LOCATION).members_by_index if self.url is not None: - serializer.write_string(_SCHEMA_WEB_LOCATION.members["url"], self.url) + serializer.write_string(members[0], self.url) if self.domain is not None: - serializer.write_string(_SCHEMA_WEB_LOCATION.members["domain"], self.domain) + serializer.write_string(members[1], self.domain) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -8509,21 +7688,21 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_WEB_LOCATION) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["url"] = de.read_string(_SCHEMA_WEB_LOCATION.members["url"]) + kwargs["url"] = de.read_string(members[0]) case 1: - kwargs["domain"] = de.read_string( - _SCHEMA_WEB_LOCATION.members["domain"] - ) + kwargs["domain"] = de.read_string(members[1]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_WEB_LOCATION, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -8534,10 +7713,11 @@ class CitationLocationWeb: value: WebLocation def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_CITATION_LOCATION, self) + serializer.write_struct(hydrate(_SCHEMA_CITATION_LOCATION), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_CITATION_LOCATION.members["web"], self.value) + members = hydrate(_SCHEMA_CITATION_LOCATION).members_by_index + serializer.write_struct(members[0], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -8554,12 +7734,11 @@ class CitationLocationDocumentChar: value: DocumentCharLocation def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_CITATION_LOCATION, self) + serializer.write_struct(hydrate(_SCHEMA_CITATION_LOCATION), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_struct( - _SCHEMA_CITATION_LOCATION.members["documentChar"], self.value - ) + members = hydrate(_SCHEMA_CITATION_LOCATION).members_by_index + serializer.write_struct(members[1], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -8576,12 +7755,11 @@ class CitationLocationDocumentPage: value: DocumentPageLocation def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_CITATION_LOCATION, self) + serializer.write_struct(hydrate(_SCHEMA_CITATION_LOCATION), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_struct( - _SCHEMA_CITATION_LOCATION.members["documentPage"], self.value - ) + members = hydrate(_SCHEMA_CITATION_LOCATION).members_by_index + serializer.write_struct(members[2], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -8599,12 +7777,11 @@ class CitationLocationDocumentChunk: value: DocumentChunkLocation def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_CITATION_LOCATION, self) + serializer.write_struct(hydrate(_SCHEMA_CITATION_LOCATION), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_struct( - _SCHEMA_CITATION_LOCATION.members["documentChunk"], self.value - ) + members = hydrate(_SCHEMA_CITATION_LOCATION).members_by_index + serializer.write_struct(members[3], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -8621,12 +7798,11 @@ class CitationLocationSearchResultLocation: value: SearchResultLocation def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_CITATION_LOCATION, self) + serializer.write_struct(hydrate(_SCHEMA_CITATION_LOCATION), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_struct( - _SCHEMA_CITATION_LOCATION.members["searchResultLocation"], self.value - ) + members = hydrate(_SCHEMA_CITATION_LOCATION).members_by_index + serializer.write_struct(members[4], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -8678,7 +7854,7 @@ class _CitationLocationDeserializer: def deserialize(self, deserializer: ShapeDeserializer) -> CitationLocation: self._result = None - deserializer.read_struct(_SCHEMA_CITATION_LOCATION, self._consumer) + deserializer.read_struct(hydrate(_SCHEMA_CITATION_LOCATION), self._consumer) if self._result is None: raise SerializationError( @@ -8724,20 +7900,16 @@ class CitationSourceContentText: value: str def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_CITATION_SOURCE_CONTENT, self) + serializer.write_struct(hydrate(_SCHEMA_CITATION_SOURCE_CONTENT), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_string( - _SCHEMA_CITATION_SOURCE_CONTENT.members["text"], self.value - ) + members = hydrate(_SCHEMA_CITATION_SOURCE_CONTENT).members_by_index + serializer.write_string(members[0], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: - return cls( - value=deserializer.read_string( - _SCHEMA_CITATION_SOURCE_CONTENT.members["text"] - ) - ) + members = hydrate(_SCHEMA_CITATION_SOURCE_CONTENT).members_by_index + return cls(value=deserializer.read_string(members[0])) @dataclass @@ -8776,7 +7948,9 @@ class _CitationSourceContentDeserializer: def deserialize(self, deserializer: ShapeDeserializer) -> CitationSourceContent: self._result = None - deserializer.read_struct(_SCHEMA_CITATION_SOURCE_CONTENT, self._consumer) + deserializer.read_struct( + hydrate(_SCHEMA_CITATION_SOURCE_CONTENT), self._consumer + ) if self._result is None: raise SerializationError( @@ -8806,7 +7980,7 @@ def _set_result(self, value: CitationSourceContent) -> None: def _serialize_citation_source_content_list( serializer: ShapeSerializer, schema: Schema, value: list[CitationSourceContent] ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_struct(member_schema, e) @@ -8859,24 +8033,23 @@ class Citation: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_CITATION, self) + serializer.write_struct(hydrate(_SCHEMA_CITATION), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_CITATION).members_by_index if self.title is not None: - serializer.write_string(_SCHEMA_CITATION.members["title"], self.title) + serializer.write_string(members[0], self.title) if self.source is not None: - serializer.write_string(_SCHEMA_CITATION.members["source"], self.source) + serializer.write_string(members[1], self.source) if self.source_content is not None: _serialize_citation_source_content_list( - serializer, - _SCHEMA_CITATION.members["sourceContent"], - self.source_content, + serializer, members[2], self.source_content ) if self.location is not None: - serializer.write_struct(_SCHEMA_CITATION.members["location"], self.location) + serializer.write_struct(members[3], self.location) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -8885,38 +8058,36 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_CITATION) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["title"] = de.read_string(_SCHEMA_CITATION.members["title"]) + kwargs["title"] = de.read_string(members[0]) case 1: - kwargs["source"] = de.read_string( - _SCHEMA_CITATION.members["source"] - ) + kwargs["source"] = de.read_string(members[1]) case 2: kwargs["source_content"] = ( - _deserialize_citation_source_content_list( - de, _SCHEMA_CITATION.members["sourceContent"] - ) + _deserialize_citation_source_content_list(de, members[2]) ) case 3: kwargs["location"] = _CitationLocationDeserializer().deserialize(de) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_CITATION, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs def _serialize_citations( serializer: ShapeSerializer, schema: Schema, value: list[Citation] ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_struct(member_schema, e) @@ -8948,20 +8119,16 @@ class CitationGeneratedContentText: value: str def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_CITATION_GENERATED_CONTENT, self) + serializer.write_struct(hydrate(_SCHEMA_CITATION_GENERATED_CONTENT), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_string( - _SCHEMA_CITATION_GENERATED_CONTENT.members["text"], self.value - ) + members = hydrate(_SCHEMA_CITATION_GENERATED_CONTENT).members_by_index + serializer.write_string(members[0], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: - return cls( - value=deserializer.read_string( - _SCHEMA_CITATION_GENERATED_CONTENT.members["text"] - ) - ) + members = hydrate(_SCHEMA_CITATION_GENERATED_CONTENT).members_by_index + return cls(value=deserializer.read_string(members[0])) @dataclass @@ -9002,7 +8169,9 @@ class _CitationGeneratedContentDeserializer: def deserialize(self, deserializer: ShapeDeserializer) -> CitationGeneratedContent: self._result = None - deserializer.read_struct(_SCHEMA_CITATION_GENERATED_CONTENT, self._consumer) + deserializer.read_struct( + hydrate(_SCHEMA_CITATION_GENERATED_CONTENT), self._consumer + ) if self._result is None: raise SerializationError( @@ -9032,7 +8201,7 @@ def _set_result(self, value: CitationGeneratedContent) -> None: def _serialize_citation_generated_content_list( serializer: ShapeSerializer, schema: Schema, value: list[CitationGeneratedContent] ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_struct(member_schema, e) @@ -9073,22 +8242,17 @@ class CitationsContentBlock: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_CITATIONS_CONTENT_BLOCK, self) + serializer.write_struct(hydrate(_SCHEMA_CITATIONS_CONTENT_BLOCK), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_CITATIONS_CONTENT_BLOCK).members_by_index if self.content is not None: _serialize_citation_generated_content_list( - serializer, - _SCHEMA_CITATIONS_CONTENT_BLOCK.members["content"], - self.content, + serializer, members[0], self.content ) if self.citations is not None: - _serialize_citations( - serializer, - _SCHEMA_CITATIONS_CONTENT_BLOCK.members["citations"], - self.citations, - ) + _serialize_citations(serializer, members[1], self.citations) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -9097,23 +8261,23 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_CITATIONS_CONTENT_BLOCK) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["content"] = _deserialize_citation_generated_content_list( - de, _SCHEMA_CITATIONS_CONTENT_BLOCK.members["content"] + de, members[0] ) case 1: - kwargs["citations"] = _deserialize_citations( - de, _SCHEMA_CITATIONS_CONTENT_BLOCK.members["citations"] - ) + kwargs["citations"] = _deserialize_citations(de, members[1]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_CITATIONS_CONTENT_BLOCK, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -9135,12 +8299,11 @@ class CitationsConfig: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_CITATIONS_CONFIG, self) + serializer.write_struct(hydrate(_SCHEMA_CITATIONS_CONFIG), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_boolean( - _SCHEMA_CITATIONS_CONFIG.members["enabled"], self.enabled - ) + members = hydrate(_SCHEMA_CITATIONS_CONFIG).members_by_index + serializer.write_boolean(members[0], self.enabled) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -9149,18 +8312,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_CITATIONS_CONFIG) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["enabled"] = de.read_boolean( - _SCHEMA_CITATIONS_CONFIG.members["enabled"] - ) + kwargs["enabled"] = de.read_boolean(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_CITATIONS_CONFIG, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) if "enabled" not in kwargs: kwargs["enabled"] = False return kwargs @@ -9185,20 +8348,16 @@ class DocumentContentBlockText: value: str def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_DOCUMENT_CONTENT_BLOCK, self) + serializer.write_struct(hydrate(_SCHEMA_DOCUMENT_CONTENT_BLOCK), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_string( - _SCHEMA_DOCUMENT_CONTENT_BLOCK.members["text"], self.value - ) + members = hydrate(_SCHEMA_DOCUMENT_CONTENT_BLOCK).members_by_index + serializer.write_string(members[0], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: - return cls( - value=deserializer.read_string( - _SCHEMA_DOCUMENT_CONTENT_BLOCK.members["text"] - ) - ) + members = hydrate(_SCHEMA_DOCUMENT_CONTENT_BLOCK).members_by_index + return cls(value=deserializer.read_string(members[0])) @dataclass @@ -9237,7 +8396,9 @@ class _DocumentContentBlockDeserializer: def deserialize(self, deserializer: ShapeDeserializer) -> DocumentContentBlock: self._result = None - deserializer.read_struct(_SCHEMA_DOCUMENT_CONTENT_BLOCK, self._consumer) + deserializer.read_struct( + hydrate(_SCHEMA_DOCUMENT_CONTENT_BLOCK), self._consumer + ) if self._result is None: raise SerializationError( @@ -9267,7 +8428,7 @@ def _set_result(self, value: DocumentContentBlock) -> None: def _serialize_document_content_blocks( serializer: ShapeSerializer, schema: Schema, value: list[DocumentContentBlock] ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_struct(member_schema, e) @@ -9299,16 +8460,16 @@ class DocumentSourceBytes: value: bytes def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_DOCUMENT_SOURCE, self) + serializer.write_struct(hydrate(_SCHEMA_DOCUMENT_SOURCE), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_blob(_SCHEMA_DOCUMENT_SOURCE.members["bytes"], self.value) + members = hydrate(_SCHEMA_DOCUMENT_SOURCE).members_by_index + serializer.write_blob(members[0], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: - return cls( - value=deserializer.read_blob(_SCHEMA_DOCUMENT_SOURCE.members["bytes"]) - ) + members = hydrate(_SCHEMA_DOCUMENT_SOURCE).members_by_index + return cls(value=deserializer.read_blob(members[0])) @dataclass @@ -9322,12 +8483,11 @@ class DocumentSourceS3Location: value: S3Location def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_DOCUMENT_SOURCE, self) + serializer.write_struct(hydrate(_SCHEMA_DOCUMENT_SOURCE), self) - def serialize_members(self, serializer: ShapeSerializer): - serializer.write_struct( - _SCHEMA_DOCUMENT_SOURCE.members["s3Location"], self.value - ) + def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_DOCUMENT_SOURCE).members_by_index + serializer.write_struct(members[1], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -9341,16 +8501,16 @@ class DocumentSourceText: value: str def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_DOCUMENT_SOURCE, self) + serializer.write_struct(hydrate(_SCHEMA_DOCUMENT_SOURCE), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_string(_SCHEMA_DOCUMENT_SOURCE.members["text"], self.value) + members = hydrate(_SCHEMA_DOCUMENT_SOURCE).members_by_index + serializer.write_string(members[2], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: - return cls( - value=deserializer.read_string(_SCHEMA_DOCUMENT_SOURCE.members["text"]) - ) + members = hydrate(_SCHEMA_DOCUMENT_SOURCE).members_by_index + return cls(value=deserializer.read_string(members[2])) @dataclass @@ -9363,20 +8523,16 @@ class DocumentSourceContent: value: list[DocumentContentBlock] def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_DOCUMENT_SOURCE, self) + serializer.write_struct(hydrate(_SCHEMA_DOCUMENT_SOURCE), self) def serialize_members(self, serializer: ShapeSerializer): - _serialize_document_content_blocks( - serializer, _SCHEMA_DOCUMENT_SOURCE.members["content"], self.value - ) + members = hydrate(_SCHEMA_DOCUMENT_SOURCE).members_by_index + _serialize_document_content_blocks(serializer, members[3], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: - return cls( - value=_deserialize_document_content_blocks( - deserializer, _SCHEMA_DOCUMENT_SOURCE.members["content"] - ) - ) + members = hydrate(_SCHEMA_DOCUMENT_SOURCE).members_by_index + return cls(value=_deserialize_document_content_blocks(deserializer, members[3])) @dataclass @@ -9418,7 +8574,7 @@ class _DocumentSourceDeserializer: def deserialize(self, deserializer: ShapeDeserializer) -> DocumentSource: self._result = None - deserializer.read_struct(_SCHEMA_DOCUMENT_SOURCE, self._consumer) + deserializer.read_struct(hydrate(_SCHEMA_DOCUMENT_SOURCE), self._consumer) if self._result is None: raise SerializationError( @@ -9496,21 +8652,18 @@ class DocumentBlock: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_DOCUMENT_BLOCK, self) + serializer.write_struct(hydrate(_SCHEMA_DOCUMENT_BLOCK), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_string(_SCHEMA_DOCUMENT_BLOCK.members["format"], self.format) - serializer.write_string(_SCHEMA_DOCUMENT_BLOCK.members["name"], self.name) - serializer.write_struct(_SCHEMA_DOCUMENT_BLOCK.members["source"], self.source) + members = hydrate(_SCHEMA_DOCUMENT_BLOCK).members_by_index + serializer.write_string(members[0], self.format) + serializer.write_string(members[1], self.name) + serializer.write_struct(members[2], self.source) if self.context is not None: - serializer.write_string( - _SCHEMA_DOCUMENT_BLOCK.members["context"], self.context - ) + serializer.write_string(members[3], self.context) if self.citations is not None: - serializer.write_struct( - _SCHEMA_DOCUMENT_BLOCK.members["citations"], self.citations - ) + serializer.write_struct(members[4], self.citations) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -9519,34 +8672,30 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_DOCUMENT_BLOCK) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["format"] = DocumentFormat( - de.read_string(_SCHEMA_DOCUMENT_BLOCK.members["format"]) - ) + kwargs["format"] = DocumentFormat(de.read_string(members[0])) case 1: - kwargs["name"] = de.read_string( - _SCHEMA_DOCUMENT_BLOCK.members["name"] - ) + kwargs["name"] = de.read_string(members[1]) case 2: kwargs["source"] = _DocumentSourceDeserializer().deserialize(de) case 3: - kwargs["context"] = de.read_string( - _SCHEMA_DOCUMENT_BLOCK.members["context"] - ) + kwargs["context"] = de.read_string(members[3]) case 4: kwargs["citations"] = CitationsConfig.deserialize(de) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_DOCUMENT_BLOCK, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) if "name" not in kwargs: kwargs["name"] = "" if "source" not in kwargs: @@ -9566,20 +8715,16 @@ class GuardrailConverseImageSourceBytes: value: bytes def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_GUARDRAIL_CONVERSE_IMAGE_SOURCE, self) + serializer.write_struct(hydrate(_SCHEMA_GUARDRAIL_CONVERSE_IMAGE_SOURCE), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_blob( - _SCHEMA_GUARDRAIL_CONVERSE_IMAGE_SOURCE.members["bytes"], self.value - ) + members = hydrate(_SCHEMA_GUARDRAIL_CONVERSE_IMAGE_SOURCE).members_by_index + serializer.write_blob(members[0], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: - return cls( - value=deserializer.read_blob( - _SCHEMA_GUARDRAIL_CONVERSE_IMAGE_SOURCE.members["bytes"] - ) - ) + members = hydrate(_SCHEMA_GUARDRAIL_CONVERSE_IMAGE_SOURCE).members_by_index + return cls(value=deserializer.read_blob(members[0])) @dataclass @@ -9620,7 +8765,7 @@ def deserialize( ) -> GuardrailConverseImageSource: self._result = None deserializer.read_struct( - _SCHEMA_GUARDRAIL_CONVERSE_IMAGE_SOURCE, self._consumer + hydrate(_SCHEMA_GUARDRAIL_CONVERSE_IMAGE_SOURCE), self._consumer ) if self._result is None: @@ -9665,15 +8810,12 @@ class GuardrailConverseImageBlock: """The image source (image bytes) of the guardrail converse image block.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_GUARDRAIL_CONVERSE_IMAGE_BLOCK, self) + serializer.write_struct(hydrate(_SCHEMA_GUARDRAIL_CONVERSE_IMAGE_BLOCK), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_string( - _SCHEMA_GUARDRAIL_CONVERSE_IMAGE_BLOCK.members["format"], self.format - ) - serializer.write_struct( - _SCHEMA_GUARDRAIL_CONVERSE_IMAGE_BLOCK.members["source"], self.source - ) + members = hydrate(_SCHEMA_GUARDRAIL_CONVERSE_IMAGE_BLOCK).members_by_index + serializer.write_string(members[0], self.format) + serializer.write_struct(members[1], self.source) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -9682,14 +8824,14 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_GUARDRAIL_CONVERSE_IMAGE_BLOCK) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["format"] = GuardrailConverseImageFormat( - de.read_string( - _SCHEMA_GUARDRAIL_CONVERSE_IMAGE_BLOCK.members["format"] - ) + de.read_string(members[0]) ) case 1: @@ -9698,11 +8840,9 @@ def _consumer(schema: Schema, de: ShapeDeserializer) -> None: ) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_GUARDRAIL_CONVERSE_IMAGE_BLOCK, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) if "format" not in kwargs: kwargs["format"] = GuardrailConverseImageFormat._corrected("") if "source" not in kwargs: @@ -9719,7 +8859,7 @@ class GuardrailConverseContentQualifier(UnknownEnumMixin, StrEnum): def _serialize_guardrail_converse_content_qualifier_list( serializer: ShapeSerializer, schema: Schema, value: list[str] ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_string(member_schema, e) @@ -9729,7 +8869,7 @@ def _deserialize_guardrail_converse_content_qualifier_list( deserializer: ShapeDeserializer, schema: Schema ) -> list[str]: result: list[str] = [] - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] def _read_value(d: ShapeDeserializer): if d.is_null(): @@ -9759,17 +8899,14 @@ class GuardrailConverseTextBlock: """The qualifier details for the guardrails contextual grounding filter.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_GUARDRAIL_CONVERSE_TEXT_BLOCK, self) + serializer.write_struct(hydrate(_SCHEMA_GUARDRAIL_CONVERSE_TEXT_BLOCK), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_string( - _SCHEMA_GUARDRAIL_CONVERSE_TEXT_BLOCK.members["text"], self.text - ) + members = hydrate(_SCHEMA_GUARDRAIL_CONVERSE_TEXT_BLOCK).members_by_index + serializer.write_string(members[0], self.text) if self.qualifiers is not None: _serialize_guardrail_converse_content_qualifier_list( - serializer, - _SCHEMA_GUARDRAIL_CONVERSE_TEXT_BLOCK.members["qualifiers"], - self.qualifiers, + serializer, members[1], self.qualifiers ) @classmethod @@ -9779,28 +8916,25 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_GUARDRAIL_CONVERSE_TEXT_BLOCK) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["text"] = de.read_string( - _SCHEMA_GUARDRAIL_CONVERSE_TEXT_BLOCK.members["text"] - ) + kwargs["text"] = de.read_string(members[0]) case 1: kwargs["qualifiers"] = ( _deserialize_guardrail_converse_content_qualifier_list( - de, - _SCHEMA_GUARDRAIL_CONVERSE_TEXT_BLOCK.members["qualifiers"], + de, members[1] ) ) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_GUARDRAIL_CONVERSE_TEXT_BLOCK, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) if "text" not in kwargs: kwargs["text"] = "" return kwargs @@ -9813,12 +8947,11 @@ class GuardrailConverseContentBlockText: value: GuardrailConverseTextBlock def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_GUARDRAIL_CONVERSE_CONTENT_BLOCK, self) + serializer.write_struct(hydrate(_SCHEMA_GUARDRAIL_CONVERSE_CONTENT_BLOCK), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_struct( - _SCHEMA_GUARDRAIL_CONVERSE_CONTENT_BLOCK.members["text"], self.value - ) + members = hydrate(_SCHEMA_GUARDRAIL_CONVERSE_CONTENT_BLOCK).members_by_index + serializer.write_struct(members[0], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -9832,12 +8965,11 @@ class GuardrailConverseContentBlockImage: value: GuardrailConverseImageBlock def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_GUARDRAIL_CONVERSE_CONTENT_BLOCK, self) + serializer.write_struct(hydrate(_SCHEMA_GUARDRAIL_CONVERSE_CONTENT_BLOCK), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_struct( - _SCHEMA_GUARDRAIL_CONVERSE_CONTENT_BLOCK.members["image"], self.value - ) + members = hydrate(_SCHEMA_GUARDRAIL_CONVERSE_CONTENT_BLOCK).members_by_index + serializer.write_struct(members[1], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -9890,7 +9022,7 @@ def deserialize( ) -> GuardrailConverseContentBlock: self._result = None deserializer.read_struct( - _SCHEMA_GUARDRAIL_CONVERSE_CONTENT_BLOCK, self._consumer + hydrate(_SCHEMA_GUARDRAIL_CONVERSE_CONTENT_BLOCK), self._consumer ) if self._result is None: @@ -9940,14 +9072,16 @@ class ImageSourceBytes: value: bytes def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_IMAGE_SOURCE, self) + serializer.write_struct(hydrate(_SCHEMA_IMAGE_SOURCE), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_blob(_SCHEMA_IMAGE_SOURCE.members["bytes"], self.value) + members = hydrate(_SCHEMA_IMAGE_SOURCE).members_by_index + serializer.write_blob(members[0], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: - return cls(value=deserializer.read_blob(_SCHEMA_IMAGE_SOURCE.members["bytes"])) + members = hydrate(_SCHEMA_IMAGE_SOURCE).members_by_index + return cls(value=deserializer.read_blob(members[0])) @dataclass @@ -9961,10 +9095,11 @@ class ImageSourceS3Location: value: S3Location def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_IMAGE_SOURCE, self) + serializer.write_struct(hydrate(_SCHEMA_IMAGE_SOURCE), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_IMAGE_SOURCE.members["s3Location"], self.value) + members = hydrate(_SCHEMA_IMAGE_SOURCE).members_by_index + serializer.write_struct(members[1], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -10004,7 +9139,7 @@ class _ImageSourceDeserializer: def deserialize(self, deserializer: ShapeDeserializer) -> ImageSource: self._result = None - deserializer.read_struct(_SCHEMA_IMAGE_SOURCE, self._consumer) + deserializer.read_struct(hydrate(_SCHEMA_IMAGE_SOURCE), self._consumer) if self._result is None: raise SerializationError( @@ -10049,13 +9184,14 @@ class ImageBlock: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_IMAGE_BLOCK, self) + serializer.write_struct(hydrate(_SCHEMA_IMAGE_BLOCK), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_string(_SCHEMA_IMAGE_BLOCK.members["format"], self.format) - serializer.write_struct(_SCHEMA_IMAGE_BLOCK.members["source"], self.source) + members = hydrate(_SCHEMA_IMAGE_BLOCK).members_by_index + serializer.write_string(members[0], self.format) + serializer.write_struct(members[1], self.source) if self.error is not None: - serializer.write_struct(_SCHEMA_IMAGE_BLOCK.members["error"], self.error) + serializer.write_struct(members[2], self.error) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -10064,13 +9200,13 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_IMAGE_BLOCK) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["format"] = ImageFormat( - de.read_string(_SCHEMA_IMAGE_BLOCK.members["format"]) - ) + kwargs["format"] = ImageFormat(de.read_string(members[0])) case 1: kwargs["source"] = _ImageSourceDeserializer().deserialize(de) @@ -10079,9 +9215,9 @@ def _consumer(schema: Schema, de: ShapeDeserializer) -> None: kwargs["error"] = ErrorBlock.deserialize(de) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_IMAGE_BLOCK, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) if "format" not in kwargs: kwargs["format"] = ImageFormat._corrected("") if "source" not in kwargs: @@ -10104,14 +9240,13 @@ class ReasoningTextBlock: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_REASONING_TEXT_BLOCK, self) + serializer.write_struct(hydrate(_SCHEMA_REASONING_TEXT_BLOCK), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_string(_SCHEMA_REASONING_TEXT_BLOCK.members["text"], self.text) + members = hydrate(_SCHEMA_REASONING_TEXT_BLOCK).members_by_index + serializer.write_string(members[0], self.text) if self.signature is not None: - serializer.write_string( - _SCHEMA_REASONING_TEXT_BLOCK.members["signature"], self.signature - ) + serializer.write_string(members[1], self.signature) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -10120,23 +9255,21 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_REASONING_TEXT_BLOCK) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["text"] = de.read_string( - _SCHEMA_REASONING_TEXT_BLOCK.members["text"] - ) + kwargs["text"] = de.read_string(members[0]) case 1: - kwargs["signature"] = de.read_string( - _SCHEMA_REASONING_TEXT_BLOCK.members["signature"] - ) + kwargs["signature"] = de.read_string(members[1]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_REASONING_TEXT_BLOCK, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) if "text" not in kwargs: kwargs["text"] = "" return kwargs @@ -10149,12 +9282,11 @@ class ReasoningContentBlockReasoningText: value: ReasoningTextBlock def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_REASONING_CONTENT_BLOCK, self) + serializer.write_struct(hydrate(_SCHEMA_REASONING_CONTENT_BLOCK), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_struct( - _SCHEMA_REASONING_CONTENT_BLOCK.members["reasoningText"], self.value - ) + members = hydrate(_SCHEMA_REASONING_CONTENT_BLOCK).members_by_index + serializer.write_struct(members[0], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -10172,20 +9304,16 @@ class ReasoningContentBlockRedactedContent: value: bytes def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_REASONING_CONTENT_BLOCK, self) + serializer.write_struct(hydrate(_SCHEMA_REASONING_CONTENT_BLOCK), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_blob( - _SCHEMA_REASONING_CONTENT_BLOCK.members["redactedContent"], self.value - ) + members = hydrate(_SCHEMA_REASONING_CONTENT_BLOCK).members_by_index + serializer.write_blob(members[1], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: - return cls( - value=deserializer.read_blob( - _SCHEMA_REASONING_CONTENT_BLOCK.members["redactedContent"] - ) - ) + members = hydrate(_SCHEMA_REASONING_CONTENT_BLOCK).members_by_index + return cls(value=deserializer.read_blob(members[1])) @dataclass @@ -10230,7 +9358,9 @@ class _ReasoningContentBlockDeserializer: def deserialize(self, deserializer: ShapeDeserializer) -> ReasoningContentBlock: self._result = None - deserializer.read_struct(_SCHEMA_REASONING_CONTENT_BLOCK, self._consumer) + deserializer.read_struct( + hydrate(_SCHEMA_REASONING_CONTENT_BLOCK), self._consumer + ) if self._result is None: raise SerializationError( @@ -10268,12 +9398,11 @@ class SearchResultContentBlock: """The actual text content""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_SEARCH_RESULT_CONTENT_BLOCK, self) + serializer.write_struct(hydrate(_SCHEMA_SEARCH_RESULT_CONTENT_BLOCK), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_string( - _SCHEMA_SEARCH_RESULT_CONTENT_BLOCK.members["text"], self.text - ) + members = hydrate(_SCHEMA_SEARCH_RESULT_CONTENT_BLOCK).members_by_index + serializer.write_string(members[0], self.text) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -10282,20 +9411,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_SEARCH_RESULT_CONTENT_BLOCK) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["text"] = de.read_string( - _SCHEMA_SEARCH_RESULT_CONTENT_BLOCK.members["text"] - ) + kwargs["text"] = de.read_string(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_SEARCH_RESULT_CONTENT_BLOCK, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) if "text" not in kwargs: kwargs["text"] = "" return kwargs @@ -10304,7 +9431,7 @@ def _consumer(schema: Schema, de: ShapeDeserializer) -> None: def _serialize_search_result_content_blocks( serializer: ShapeSerializer, schema: Schema, value: list[SearchResultContentBlock] ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_struct(member_schema, e) @@ -10350,22 +9477,15 @@ class SearchResultBlock: """Configuration setting for citations""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_SEARCH_RESULT_BLOCK, self) + serializer.write_struct(hydrate(_SCHEMA_SEARCH_RESULT_BLOCK), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_string( - _SCHEMA_SEARCH_RESULT_BLOCK.members["source"], self.source - ) - serializer.write_string( - _SCHEMA_SEARCH_RESULT_BLOCK.members["title"], self.title - ) - _serialize_search_result_content_blocks( - serializer, _SCHEMA_SEARCH_RESULT_BLOCK.members["content"], self.content - ) + members = hydrate(_SCHEMA_SEARCH_RESULT_BLOCK).members_by_index + serializer.write_string(members[0], self.source) + serializer.write_string(members[1], self.title) + _serialize_search_result_content_blocks(serializer, members[2], self.content) if self.citations is not None: - serializer.write_struct( - _SCHEMA_SEARCH_RESULT_BLOCK.members["citations"], self.citations - ) + serializer.write_struct(members[3], self.citations) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -10374,31 +9494,29 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_SEARCH_RESULT_BLOCK) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["source"] = de.read_string( - _SCHEMA_SEARCH_RESULT_BLOCK.members["source"] - ) + kwargs["source"] = de.read_string(members[0]) case 1: - kwargs["title"] = de.read_string( - _SCHEMA_SEARCH_RESULT_BLOCK.members["title"] - ) + kwargs["title"] = de.read_string(members[1]) case 2: kwargs["content"] = _deserialize_search_result_content_blocks( - de, _SCHEMA_SEARCH_RESULT_BLOCK.members["content"] + de, members[2] ) case 3: kwargs["citations"] = CitationsConfig.deserialize(de) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_SEARCH_RESULT_BLOCK, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) if "source" not in kwargs: kwargs["source"] = "" if "title" not in kwargs: @@ -10432,19 +9550,18 @@ class ToolReference: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_TOOL_REFERENCE, self) + serializer.write_struct(hydrate(_SCHEMA_TOOL_REFERENCE), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_TOOL_REFERENCE).members_by_index if self.type is not None: - serializer.write_string(_SCHEMA_TOOL_REFERENCE.members["type"], self.type) + serializer.write_string(members[0], self.type) if self.name is not None: - serializer.write_string(_SCHEMA_TOOL_REFERENCE.members["name"], self.name) + serializer.write_string(members[1], self.name) if self.server_name is not None: - serializer.write_string( - _SCHEMA_TOOL_REFERENCE.members["serverName"], self.server_name - ) + serializer.write_string(members[2], self.server_name) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -10453,28 +9570,24 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_TOOL_REFERENCE) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["type"] = de.read_string( - _SCHEMA_TOOL_REFERENCE.members["type"] - ) + kwargs["type"] = de.read_string(members[0]) case 1: - kwargs["name"] = de.read_string( - _SCHEMA_TOOL_REFERENCE.members["name"] - ) + kwargs["name"] = de.read_string(members[1]) case 2: - kwargs["server_name"] = de.read_string( - _SCHEMA_TOOL_REFERENCE.members["serverName"] - ) + kwargs["server_name"] = de.read_string(members[2]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_TOOL_REFERENCE, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @classmethod @@ -10495,10 +9608,11 @@ class ToolAdditionBlock: """A reference to the tool to add to the available tool set.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_TOOL_ADDITION_BLOCK, self) + serializer.write_struct(hydrate(_SCHEMA_TOOL_ADDITION_BLOCK), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_TOOL_ADDITION_BLOCK.members["tool"], self.tool) + members = hydrate(_SCHEMA_TOOL_ADDITION_BLOCK).members_by_index + serializer.write_struct(members[0], self.tool) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -10507,16 +9621,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_TOOL_ADDITION_BLOCK) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["tool"] = ToolReference.deserialize(de) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_TOOL_ADDITION_BLOCK, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) if "tool" not in kwargs: kwargs["tool"] = ToolReference._smithy_default() return kwargs @@ -10535,10 +9651,11 @@ class ToolRemovalBlock: """A reference to the tool to remove from the available tool set.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_TOOL_REMOVAL_BLOCK, self) + serializer.write_struct(hydrate(_SCHEMA_TOOL_REMOVAL_BLOCK), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_TOOL_REMOVAL_BLOCK.members["tool"], self.tool) + members = hydrate(_SCHEMA_TOOL_REMOVAL_BLOCK).members_by_index + serializer.write_struct(members[0], self.tool) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -10547,16 +9664,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_TOOL_REMOVAL_BLOCK) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["tool"] = ToolReference.deserialize(de) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_TOOL_REMOVAL_BLOCK, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) if "tool" not in kwargs: kwargs["tool"] = ToolReference._smithy_default() return kwargs @@ -10581,14 +9700,16 @@ class VideoSourceBytes: value: bytes def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_VIDEO_SOURCE, self) + serializer.write_struct(hydrate(_SCHEMA_VIDEO_SOURCE), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_blob(_SCHEMA_VIDEO_SOURCE.members["bytes"], self.value) + members = hydrate(_SCHEMA_VIDEO_SOURCE).members_by_index + serializer.write_blob(members[0], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: - return cls(value=deserializer.read_blob(_SCHEMA_VIDEO_SOURCE.members["bytes"])) + members = hydrate(_SCHEMA_VIDEO_SOURCE).members_by_index + return cls(value=deserializer.read_blob(members[0])) @dataclass @@ -10602,10 +9723,11 @@ class VideoSourceS3Location: value: S3Location def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_VIDEO_SOURCE, self) + serializer.write_struct(hydrate(_SCHEMA_VIDEO_SOURCE), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_VIDEO_SOURCE.members["s3Location"], self.value) + members = hydrate(_SCHEMA_VIDEO_SOURCE).members_by_index + serializer.write_struct(members[1], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -10649,7 +9771,7 @@ class _VideoSourceDeserializer: def deserialize(self, deserializer: ShapeDeserializer) -> VideoSource: self._result = None - deserializer.read_struct(_SCHEMA_VIDEO_SOURCE, self._consumer) + deserializer.read_struct(hydrate(_SCHEMA_VIDEO_SOURCE), self._consumer) if self._result is None: raise SerializationError( @@ -10688,11 +9810,12 @@ class VideoBlock: """The block's source.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_VIDEO_BLOCK, self) + serializer.write_struct(hydrate(_SCHEMA_VIDEO_BLOCK), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_string(_SCHEMA_VIDEO_BLOCK.members["format"], self.format) - serializer.write_struct(_SCHEMA_VIDEO_BLOCK.members["source"], self.source) + members = hydrate(_SCHEMA_VIDEO_BLOCK).members_by_index + serializer.write_string(members[0], self.format) + serializer.write_struct(members[1], self.source) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -10701,21 +9824,21 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_VIDEO_BLOCK) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["format"] = VideoFormat( - de.read_string(_SCHEMA_VIDEO_BLOCK.members["format"]) - ) + kwargs["format"] = VideoFormat(de.read_string(members[0])) case 1: kwargs["source"] = _VideoSourceDeserializer().deserialize(de) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_VIDEO_BLOCK, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) if "format" not in kwargs: kwargs["format"] = VideoFormat._corrected("") if "source" not in kwargs: @@ -10730,20 +9853,16 @@ class ToolResultContentBlockJson: value: Document def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_TOOL_RESULT_CONTENT_BLOCK, self) + serializer.write_struct(hydrate(_SCHEMA_TOOL_RESULT_CONTENT_BLOCK), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_document( - _SCHEMA_TOOL_RESULT_CONTENT_BLOCK.members["json"], self.value - ) + members = hydrate(_SCHEMA_TOOL_RESULT_CONTENT_BLOCK).members_by_index + serializer.write_document(members[0], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: - return cls( - value=deserializer.read_document( - _SCHEMA_TOOL_RESULT_CONTENT_BLOCK.members["json"] - ) - ) + members = hydrate(_SCHEMA_TOOL_RESULT_CONTENT_BLOCK).members_by_index + return cls(value=deserializer.read_document(members[0])) @dataclass @@ -10753,20 +9872,16 @@ class ToolResultContentBlockText: value: str def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_TOOL_RESULT_CONTENT_BLOCK, self) + serializer.write_struct(hydrate(_SCHEMA_TOOL_RESULT_CONTENT_BLOCK), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_string( - _SCHEMA_TOOL_RESULT_CONTENT_BLOCK.members["text"], self.value - ) + members = hydrate(_SCHEMA_TOOL_RESULT_CONTENT_BLOCK).members_by_index + serializer.write_string(members[1], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: - return cls( - value=deserializer.read_string( - _SCHEMA_TOOL_RESULT_CONTENT_BLOCK.members["text"] - ) - ) + members = hydrate(_SCHEMA_TOOL_RESULT_CONTENT_BLOCK).members_by_index + return cls(value=deserializer.read_string(members[1])) @dataclass @@ -10782,12 +9897,11 @@ class ToolResultContentBlockImage: value: ImageBlock def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_TOOL_RESULT_CONTENT_BLOCK, self) + serializer.write_struct(hydrate(_SCHEMA_TOOL_RESULT_CONTENT_BLOCK), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_struct( - _SCHEMA_TOOL_RESULT_CONTENT_BLOCK.members["image"], self.value - ) + members = hydrate(_SCHEMA_TOOL_RESULT_CONTENT_BLOCK).members_by_index + serializer.write_struct(members[2], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -10801,12 +9915,11 @@ class ToolResultContentBlockDocument: value: DocumentBlock def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_TOOL_RESULT_CONTENT_BLOCK, self) + serializer.write_struct(hydrate(_SCHEMA_TOOL_RESULT_CONTENT_BLOCK), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_struct( - _SCHEMA_TOOL_RESULT_CONTENT_BLOCK.members["document"], self.value - ) + members = hydrate(_SCHEMA_TOOL_RESULT_CONTENT_BLOCK).members_by_index + serializer.write_struct(members[3], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -10820,12 +9933,11 @@ class ToolResultContentBlockVideo: value: VideoBlock def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_TOOL_RESULT_CONTENT_BLOCK, self) + serializer.write_struct(hydrate(_SCHEMA_TOOL_RESULT_CONTENT_BLOCK), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_struct( - _SCHEMA_TOOL_RESULT_CONTENT_BLOCK.members["video"], self.value - ) + members = hydrate(_SCHEMA_TOOL_RESULT_CONTENT_BLOCK).members_by_index + serializer.write_struct(members[4], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -10839,12 +9951,11 @@ class ToolResultContentBlockSearchResult: value: SearchResultBlock def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_TOOL_RESULT_CONTENT_BLOCK, self) + serializer.write_struct(hydrate(_SCHEMA_TOOL_RESULT_CONTENT_BLOCK), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_struct( - _SCHEMA_TOOL_RESULT_CONTENT_BLOCK.members["searchResult"], self.value - ) + members = hydrate(_SCHEMA_TOOL_RESULT_CONTENT_BLOCK).members_by_index + serializer.write_struct(members[5], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -10897,7 +10008,9 @@ class _ToolResultContentBlockDeserializer: def deserialize(self, deserializer: ShapeDeserializer) -> ToolResultContentBlock: self._result = None - deserializer.read_struct(_SCHEMA_TOOL_RESULT_CONTENT_BLOCK, self._consumer) + deserializer.read_struct( + hydrate(_SCHEMA_TOOL_RESULT_CONTENT_BLOCK), self._consumer + ) if self._result is None: raise SerializationError( @@ -10942,7 +10055,7 @@ def _set_result(self, value: ToolResultContentBlock) -> None: def _serialize_tool_result_content_blocks( serializer: ShapeSerializer, schema: Schema, value: list[ToolResultContentBlock] ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_struct(member_schema, e) @@ -10998,24 +10111,17 @@ class ToolResultBlock: """The type for the tool result content block.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_TOOL_RESULT_BLOCK, self) + serializer.write_struct(hydrate(_SCHEMA_TOOL_RESULT_BLOCK), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_string( - _SCHEMA_TOOL_RESULT_BLOCK.members["toolUseId"], self.tool_use_id - ) - _serialize_tool_result_content_blocks( - serializer, _SCHEMA_TOOL_RESULT_BLOCK.members["content"], self.content - ) + members = hydrate(_SCHEMA_TOOL_RESULT_BLOCK).members_by_index + serializer.write_string(members[0], self.tool_use_id) + _serialize_tool_result_content_blocks(serializer, members[1], self.content) if self.status is not None: - serializer.write_string( - _SCHEMA_TOOL_RESULT_BLOCK.members["status"], self.status - ) + serializer.write_string(members[2], self.status) if self.type is not None: - serializer.write_string( - _SCHEMA_TOOL_RESULT_BLOCK.members["type"], self.type - ) + serializer.write_string(members[3], self.type) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -11024,33 +10130,29 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_TOOL_RESULT_BLOCK) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["tool_use_id"] = de.read_string( - _SCHEMA_TOOL_RESULT_BLOCK.members["toolUseId"] - ) + kwargs["tool_use_id"] = de.read_string(members[0]) case 1: kwargs["content"] = _deserialize_tool_result_content_blocks( - de, _SCHEMA_TOOL_RESULT_BLOCK.members["content"] + de, members[1] ) case 2: - kwargs["status"] = ToolResultStatus( - de.read_string(_SCHEMA_TOOL_RESULT_BLOCK.members["status"]) - ) + kwargs["status"] = ToolResultStatus(de.read_string(members[2])) case 3: - kwargs["type"] = de.read_string( - _SCHEMA_TOOL_RESULT_BLOCK.members["type"] - ) + kwargs["type"] = de.read_string(members[3]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_TOOL_RESULT_BLOCK, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) if "tool_use_id" not in kwargs: kwargs["tool_use_id"] = "" if "content" not in kwargs: @@ -11086,16 +10188,15 @@ class ToolUseBlock: """The type for the tool request.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_TOOL_USE_BLOCK, self) + serializer.write_struct(hydrate(_SCHEMA_TOOL_USE_BLOCK), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_string( - _SCHEMA_TOOL_USE_BLOCK.members["toolUseId"], self.tool_use_id - ) - serializer.write_string(_SCHEMA_TOOL_USE_BLOCK.members["name"], self.name) - serializer.write_document(_SCHEMA_TOOL_USE_BLOCK.members["input"], self.input) + members = hydrate(_SCHEMA_TOOL_USE_BLOCK).members_by_index + serializer.write_string(members[0], self.tool_use_id) + serializer.write_string(members[1], self.name) + serializer.write_document(members[2], self.input) if self.type is not None: - serializer.write_string(_SCHEMA_TOOL_USE_BLOCK.members["type"], self.type) + serializer.write_string(members[3], self.type) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -11104,33 +10205,27 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_TOOL_USE_BLOCK) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["tool_use_id"] = de.read_string( - _SCHEMA_TOOL_USE_BLOCK.members["toolUseId"] - ) + kwargs["tool_use_id"] = de.read_string(members[0]) case 1: - kwargs["name"] = de.read_string( - _SCHEMA_TOOL_USE_BLOCK.members["name"] - ) + kwargs["name"] = de.read_string(members[1]) case 2: - kwargs["input"] = de.read_document( - _SCHEMA_TOOL_USE_BLOCK.members["input"] - ) + kwargs["input"] = de.read_document(members[2]) case 3: - kwargs["type"] = ToolUseType( - de.read_string(_SCHEMA_TOOL_USE_BLOCK.members["type"]) - ) + kwargs["type"] = ToolUseType(de.read_string(members[3])) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_TOOL_USE_BLOCK, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) if "tool_use_id" not in kwargs: kwargs["tool_use_id"] = "" if "name" not in kwargs: @@ -11147,16 +10242,16 @@ class ContentBlockText: value: str def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_CONTENT_BLOCK, self) + serializer.write_struct(hydrate(_SCHEMA_CONTENT_BLOCK), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_string(_SCHEMA_CONTENT_BLOCK.members["text"], self.value) + members = hydrate(_SCHEMA_CONTENT_BLOCK).members_by_index + serializer.write_string(members[0], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: - return cls( - value=deserializer.read_string(_SCHEMA_CONTENT_BLOCK.members["text"]) - ) + members = hydrate(_SCHEMA_CONTENT_BLOCK).members_by_index + return cls(value=deserializer.read_string(members[0])) @dataclass @@ -11171,10 +10266,11 @@ class ContentBlockImage: value: ImageBlock def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_CONTENT_BLOCK, self) + serializer.write_struct(hydrate(_SCHEMA_CONTENT_BLOCK), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_CONTENT_BLOCK.members["image"], self.value) + members = hydrate(_SCHEMA_CONTENT_BLOCK).members_by_index + serializer.write_struct(members[1], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -11188,10 +10284,11 @@ class ContentBlockDocument: value: DocumentBlock def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_CONTENT_BLOCK, self) + serializer.write_struct(hydrate(_SCHEMA_CONTENT_BLOCK), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_CONTENT_BLOCK.members["document"], self.value) + members = hydrate(_SCHEMA_CONTENT_BLOCK).members_by_index + serializer.write_struct(members[2], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -11205,10 +10302,11 @@ class ContentBlockVideo: value: VideoBlock def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_CONTENT_BLOCK, self) + serializer.write_struct(hydrate(_SCHEMA_CONTENT_BLOCK), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_CONTENT_BLOCK.members["video"], self.value) + members = hydrate(_SCHEMA_CONTENT_BLOCK).members_by_index + serializer.write_struct(members[3], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -11222,10 +10320,11 @@ class ContentBlockAudio: value: AudioBlock def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_CONTENT_BLOCK, self) + serializer.write_struct(hydrate(_SCHEMA_CONTENT_BLOCK), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_CONTENT_BLOCK.members["audio"], self.value) + members = hydrate(_SCHEMA_CONTENT_BLOCK).members_by_index + serializer.write_struct(members[4], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -11239,10 +10338,11 @@ class ContentBlockToolUse: value: ToolUseBlock def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_CONTENT_BLOCK, self) + serializer.write_struct(hydrate(_SCHEMA_CONTENT_BLOCK), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_CONTENT_BLOCK.members["toolUse"], self.value) + members = hydrate(_SCHEMA_CONTENT_BLOCK).members_by_index + serializer.write_struct(members[5], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -11256,10 +10356,11 @@ class ContentBlockToolResult: value: ToolResultBlock def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_CONTENT_BLOCK, self) + serializer.write_struct(hydrate(_SCHEMA_CONTENT_BLOCK), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_CONTENT_BLOCK.members["toolResult"], self.value) + members = hydrate(_SCHEMA_CONTENT_BLOCK).members_by_index + serializer.write_struct(members[6], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -11280,12 +10381,11 @@ class ContentBlockGuardContent: value: GuardrailConverseContentBlock def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_CONTENT_BLOCK, self) + serializer.write_struct(hydrate(_SCHEMA_CONTENT_BLOCK), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_struct( - _SCHEMA_CONTENT_BLOCK.members["guardContent"], self.value - ) + members = hydrate(_SCHEMA_CONTENT_BLOCK).members_by_index + serializer.write_struct(members[7], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -11301,10 +10401,11 @@ class ContentBlockCachePoint: value: CachePointBlock def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_CONTENT_BLOCK, self) + serializer.write_struct(hydrate(_SCHEMA_CONTENT_BLOCK), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_CONTENT_BLOCK.members["cachePoint"], self.value) + members = hydrate(_SCHEMA_CONTENT_BLOCK).members_by_index + serializer.write_struct(members[8], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -11322,12 +10423,11 @@ class ContentBlockReasoningContent: value: ReasoningContentBlock def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_CONTENT_BLOCK, self) + serializer.write_struct(hydrate(_SCHEMA_CONTENT_BLOCK), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_struct( - _SCHEMA_CONTENT_BLOCK.members["reasoningContent"], self.value - ) + members = hydrate(_SCHEMA_CONTENT_BLOCK).members_by_index + serializer.write_struct(members[9], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -11345,12 +10445,11 @@ class ContentBlockCitationsContent: value: CitationsContentBlock def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_CONTENT_BLOCK, self) + serializer.write_struct(hydrate(_SCHEMA_CONTENT_BLOCK), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_struct( - _SCHEMA_CONTENT_BLOCK.members["citationsContent"], self.value - ) + members = hydrate(_SCHEMA_CONTENT_BLOCK).members_by_index + serializer.write_struct(members[10], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -11364,12 +10463,11 @@ class ContentBlockSearchResult: value: SearchResultBlock def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_CONTENT_BLOCK, self) + serializer.write_struct(hydrate(_SCHEMA_CONTENT_BLOCK), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_struct( - _SCHEMA_CONTENT_BLOCK.members["searchResult"], self.value - ) + members = hydrate(_SCHEMA_CONTENT_BLOCK).members_by_index + serializer.write_struct(members[11], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -11388,12 +10486,11 @@ class ContentBlockToolAddition: value: ToolAdditionBlock def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_CONTENT_BLOCK, self) + serializer.write_struct(hydrate(_SCHEMA_CONTENT_BLOCK), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_struct( - _SCHEMA_CONTENT_BLOCK.members["toolAddition"], self.value - ) + members = hydrate(_SCHEMA_CONTENT_BLOCK).members_by_index + serializer.write_struct(members[12], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -11412,12 +10509,11 @@ class ContentBlockToolRemoval: value: ToolRemovalBlock def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_CONTENT_BLOCK, self) + serializer.write_struct(hydrate(_SCHEMA_CONTENT_BLOCK), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_struct( - _SCHEMA_CONTENT_BLOCK.members["toolRemoval"], self.value - ) + members = hydrate(_SCHEMA_CONTENT_BLOCK).members_by_index + serializer.write_struct(members[13], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -11480,7 +10576,7 @@ class _ContentBlockDeserializer: def deserialize(self, deserializer: ShapeDeserializer) -> ContentBlock: self._result = None - deserializer.read_struct(_SCHEMA_CONTENT_BLOCK, self._consumer) + deserializer.read_struct(hydrate(_SCHEMA_CONTENT_BLOCK), self._consumer) if self._result is None: raise SerializationError( @@ -11547,7 +10643,7 @@ def _set_result(self, value: ContentBlock) -> None: def _serialize_content_blocks( serializer: ShapeSerializer, schema: Schema, value: list[ContentBlock] ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_struct(member_schema, e) @@ -11604,13 +10700,12 @@ class Message: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_MESSAGE, self) + serializer.write_struct(hydrate(_SCHEMA_MESSAGE), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_string(_SCHEMA_MESSAGE.members["role"], self.role) - _serialize_content_blocks( - serializer, _SCHEMA_MESSAGE.members["content"], self.content - ) + members = hydrate(_SCHEMA_MESSAGE).members_by_index + serializer.write_string(members[0], self.role) + _serialize_content_blocks(serializer, members[1], self.content) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -11619,23 +10714,21 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_MESSAGE) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["role"] = ConversationRole( - de.read_string(_SCHEMA_MESSAGE.members["role"]) - ) + kwargs["role"] = ConversationRole(de.read_string(members[0])) case 1: - kwargs["content"] = _deserialize_content_blocks( - de, _SCHEMA_MESSAGE.members["content"] - ) + kwargs["content"] = _deserialize_content_blocks(de, members[1]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_MESSAGE, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) if "role" not in kwargs: kwargs["role"] = ConversationRole._corrected("") if "content" not in kwargs: @@ -11646,7 +10739,7 @@ def _consumer(schema: Schema, de: ShapeDeserializer) -> None: def _serialize_messages( serializer: ShapeSerializer, schema: Schema, value: list[Message] ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_struct(member_schema, e) @@ -11686,21 +10779,16 @@ class JsonSchemaDefinition: """A description of the JSON schema.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_JSON_SCHEMA_DEFINITION, self) + serializer.write_struct(hydrate(_SCHEMA_JSON_SCHEMA_DEFINITION), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_string( - _SCHEMA_JSON_SCHEMA_DEFINITION.members["schema"], self.schema - ) + members = hydrate(_SCHEMA_JSON_SCHEMA_DEFINITION).members_by_index + serializer.write_string(members[0], self.schema) if self.name is not None: - serializer.write_string( - _SCHEMA_JSON_SCHEMA_DEFINITION.members["name"], self.name - ) + serializer.write_string(members[1], self.name) if self.description is not None: - serializer.write_string( - _SCHEMA_JSON_SCHEMA_DEFINITION.members["description"], self.description - ) + serializer.write_string(members[2], self.description) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -11709,28 +10797,24 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_JSON_SCHEMA_DEFINITION) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["schema"] = de.read_string( - _SCHEMA_JSON_SCHEMA_DEFINITION.members["schema"] - ) + kwargs["schema"] = de.read_string(members[0]) case 1: - kwargs["name"] = de.read_string( - _SCHEMA_JSON_SCHEMA_DEFINITION.members["name"] - ) + kwargs["name"] = de.read_string(members[1]) case 2: - kwargs["description"] = de.read_string( - _SCHEMA_JSON_SCHEMA_DEFINITION.members["description"] - ) + kwargs["description"] = de.read_string(members[2]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_JSON_SCHEMA_DEFINITION, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) if "schema" not in kwargs: kwargs["schema"] = "" return kwargs @@ -11743,12 +10827,11 @@ class OutputFormatStructureJsonSchema: value: JsonSchemaDefinition def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_OUTPUT_FORMAT_STRUCTURE, self) + serializer.write_struct(hydrate(_SCHEMA_OUTPUT_FORMAT_STRUCTURE), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_struct( - _SCHEMA_OUTPUT_FORMAT_STRUCTURE.members["jsonSchema"], self.value - ) + members = hydrate(_SCHEMA_OUTPUT_FORMAT_STRUCTURE).members_by_index + serializer.write_struct(members[0], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -11790,7 +10873,9 @@ class _OutputFormatStructureDeserializer: def deserialize(self, deserializer: ShapeDeserializer) -> OutputFormatStructure: self._result = None - deserializer.read_struct(_SCHEMA_OUTPUT_FORMAT_STRUCTURE, self._consumer) + deserializer.read_struct( + hydrate(_SCHEMA_OUTPUT_FORMAT_STRUCTURE), self._consumer + ) if self._result is None: raise SerializationError( @@ -11837,13 +10922,12 @@ class OutputFormat: """The structure that the model's output must adhere to.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_OUTPUT_FORMAT, self) + serializer.write_struct(hydrate(_SCHEMA_OUTPUT_FORMAT), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_string(_SCHEMA_OUTPUT_FORMAT.members["type"], self.type) - serializer.write_struct( - _SCHEMA_OUTPUT_FORMAT.members["structure"], self.structure - ) + members = hydrate(_SCHEMA_OUTPUT_FORMAT).members_by_index + serializer.write_string(members[0], self.type) + serializer.write_struct(members[1], self.structure) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -11852,13 +10936,13 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_OUTPUT_FORMAT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["type"] = OutputFormatType( - de.read_string(_SCHEMA_OUTPUT_FORMAT.members["type"]) - ) + kwargs["type"] = OutputFormatType(de.read_string(members[0])) case 1: kwargs["structure"] = ( @@ -11866,9 +10950,9 @@ def _consumer(schema: Schema, de: ShapeDeserializer) -> None: ) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_OUTPUT_FORMAT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) if "type" not in kwargs: kwargs["type"] = OutputFormatType._corrected("") if "structure" not in kwargs: @@ -11902,18 +10986,15 @@ class OutputConfig: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_OUTPUT_CONFIG, self) + serializer.write_struct(hydrate(_SCHEMA_OUTPUT_CONFIG), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_OUTPUT_CONFIG).members_by_index if self.text_format is not None: - serializer.write_struct( - _SCHEMA_OUTPUT_CONFIG.members["textFormat"], self.text_format - ) + serializer.write_struct(members[0], self.text_format) if self.effort is not None: - serializer.write_string( - _SCHEMA_OUTPUT_CONFIG.members["effort"], self.effort - ) + serializer.write_string(members[1], self.effort) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -11922,21 +11003,21 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_OUTPUT_CONFIG) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["text_format"] = OutputFormat.deserialize(de) case 1: - kwargs["effort"] = de.read_string( - _SCHEMA_OUTPUT_CONFIG.members["effort"] - ) + kwargs["effort"] = de.read_string(members[1]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_OUTPUT_CONFIG, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -11953,12 +11034,11 @@ class PerformanceConfiguration: """To use a latency-optimized version of the model, set to `optimized`.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_PERFORMANCE_CONFIGURATION, self) + serializer.write_struct(hydrate(_SCHEMA_PERFORMANCE_CONFIGURATION), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_string( - _SCHEMA_PERFORMANCE_CONFIGURATION.members["latency"], self.latency - ) + members = hydrate(_SCHEMA_PERFORMANCE_CONFIGURATION).members_by_index + serializer.write_string(members[0], self.latency) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -11967,20 +11047,20 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_PERFORMANCE_CONFIGURATION) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["latency"] = PerformanceConfigLatency( - de.read_string( - _SCHEMA_PERFORMANCE_CONFIGURATION.members["latency"] - ) + de.read_string(members[0]) ) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_PERFORMANCE_CONFIGURATION, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -11991,20 +11071,16 @@ class PromptVariableValuesText: value: str def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_PROMPT_VARIABLE_VALUES, self) + serializer.write_struct(hydrate(_SCHEMA_PROMPT_VARIABLE_VALUES), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_string( - _SCHEMA_PROMPT_VARIABLE_VALUES.members["text"], self.value - ) + members = hydrate(_SCHEMA_PROMPT_VARIABLE_VALUES).members_by_index + serializer.write_string(members[0], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: - return cls( - value=deserializer.read_string( - _SCHEMA_PROMPT_VARIABLE_VALUES.members["text"] - ) - ) + members = hydrate(_SCHEMA_PROMPT_VARIABLE_VALUES).members_by_index + return cls(value=deserializer.read_string(members[0])) @dataclass @@ -12045,7 +11121,9 @@ class _PromptVariableValuesDeserializer: def deserialize(self, deserializer: ShapeDeserializer) -> PromptVariableValues: self._result = None - deserializer.read_struct(_SCHEMA_PROMPT_VARIABLE_VALUES, self._consumer) + deserializer.read_struct( + hydrate(_SCHEMA_PROMPT_VARIABLE_VALUES), self._consumer + ) if self._result is None: raise SerializationError( @@ -12076,7 +11154,7 @@ def _serialize_prompt_variable_map( serializer: ShapeSerializer, schema: Schema, value: dict[str, PromptVariableValues] ) -> None: with serializer.begin_map(schema, len(value)) as m: - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] for k, v in value.items(): m.entry(k, lambda vs: vs.write_struct(value_schema, v)) @@ -12085,7 +11163,7 @@ def _deserialize_prompt_variable_map( deserializer: ShapeDeserializer, schema: Schema ) -> dict[str, PromptVariableValues]: result: dict[str, PromptVariableValues] = {} - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] def _read_value(k: str, d: ShapeDeserializer): if d.is_null(): @@ -12102,7 +11180,7 @@ def _serialize_request_metadata( serializer: ShapeSerializer, schema: Schema, value: dict[str, str] ) -> None: with serializer.begin_map(schema, len(value)) as m: - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] for k, v in value.items(): m.entry(k, lambda vs: vs.write_string(value_schema, v)) @@ -12111,7 +11189,7 @@ def _deserialize_request_metadata( deserializer: ShapeDeserializer, schema: Schema ) -> dict[str, str]: result: dict[str, str] = {} - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] def _read_value(k: str, d: ShapeDeserializer): if d.is_null(): @@ -12142,10 +11220,11 @@ class ServiceTier: """Specifies the processing tier type used for serving the request.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_SERVICE_TIER, self) + serializer.write_struct(hydrate(_SCHEMA_SERVICE_TIER), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_string(_SCHEMA_SERVICE_TIER.members["type"], self.type) + members = hydrate(_SCHEMA_SERVICE_TIER).members_by_index + serializer.write_string(members[0], self.type) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -12154,18 +11233,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_SERVICE_TIER) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["type"] = ServiceTierType( - de.read_string(_SCHEMA_SERVICE_TIER.members["type"]) - ) + kwargs["type"] = ServiceTierType(de.read_string(members[0])) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_SERVICE_TIER, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) if "type" not in kwargs: kwargs["type"] = ServiceTierType._corrected("") return kwargs @@ -12178,18 +11257,16 @@ class SystemContentBlockText: value: str def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_SYSTEM_CONTENT_BLOCK, self) + serializer.write_struct(hydrate(_SCHEMA_SYSTEM_CONTENT_BLOCK), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_string( - _SCHEMA_SYSTEM_CONTENT_BLOCK.members["text"], self.value - ) + members = hydrate(_SCHEMA_SYSTEM_CONTENT_BLOCK).members_by_index + serializer.write_string(members[0], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: - return cls( - value=deserializer.read_string(_SCHEMA_SYSTEM_CONTENT_BLOCK.members["text"]) - ) + members = hydrate(_SCHEMA_SYSTEM_CONTENT_BLOCK).members_by_index + return cls(value=deserializer.read_string(members[0])) @dataclass @@ -12208,12 +11285,11 @@ class SystemContentBlockGuardContent: value: GuardrailConverseContentBlock def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_SYSTEM_CONTENT_BLOCK, self) + serializer.write_struct(hydrate(_SCHEMA_SYSTEM_CONTENT_BLOCK), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_struct( - _SCHEMA_SYSTEM_CONTENT_BLOCK.members["guardContent"], self.value - ) + members = hydrate(_SCHEMA_SYSTEM_CONTENT_BLOCK).members_by_index + serializer.write_struct(members[1], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -12229,12 +11305,11 @@ class SystemContentBlockCachePoint: value: CachePointBlock def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_SYSTEM_CONTENT_BLOCK, self) + serializer.write_struct(hydrate(_SCHEMA_SYSTEM_CONTENT_BLOCK), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_struct( - _SCHEMA_SYSTEM_CONTENT_BLOCK.members["cachePoint"], self.value - ) + members = hydrate(_SCHEMA_SYSTEM_CONTENT_BLOCK).members_by_index + serializer.write_struct(members[2], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -12283,7 +11358,7 @@ class _SystemContentBlockDeserializer: def deserialize(self, deserializer: ShapeDeserializer) -> SystemContentBlock: self._result = None - deserializer.read_struct(_SCHEMA_SYSTEM_CONTENT_BLOCK, self._consumer) + deserializer.read_struct(hydrate(_SCHEMA_SYSTEM_CONTENT_BLOCK), self._consumer) if self._result is None: raise SerializationError( @@ -12319,7 +11394,7 @@ def _set_result(self, value: SystemContentBlock) -> None: def _serialize_system_content_blocks( serializer: ShapeSerializer, schema: Schema, value: list[SystemContentBlock] ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_struct(member_schema, e) @@ -12352,7 +11427,7 @@ class AnyToolChoice: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_ANY_TOOL_CHOICE, self) + serializer.write_struct(hydrate(_SCHEMA_ANY_TOOL_CHOICE), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -12364,13 +11439,14 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_ANY_TOOL_CHOICE) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_ANY_TOOL_CHOICE, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -12385,7 +11461,7 @@ class AutoToolChoice: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_AUTO_TOOL_CHOICE, self) + serializer.write_struct(hydrate(_SCHEMA_AUTO_TOOL_CHOICE), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -12397,13 +11473,14 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_AUTO_TOOL_CHOICE) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_AUTO_TOOL_CHOICE, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -12424,10 +11501,11 @@ class SpecificToolChoice: """The name of the tool that the model must request.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_SPECIFIC_TOOL_CHOICE, self) + serializer.write_struct(hydrate(_SCHEMA_SPECIFIC_TOOL_CHOICE), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_string(_SCHEMA_SPECIFIC_TOOL_CHOICE.members["name"], self.name) + members = hydrate(_SCHEMA_SPECIFIC_TOOL_CHOICE).members_by_index + serializer.write_string(members[0], self.name) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -12436,18 +11514,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_SPECIFIC_TOOL_CHOICE) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["name"] = de.read_string( - _SCHEMA_SPECIFIC_TOOL_CHOICE.members["name"] - ) + kwargs["name"] = de.read_string(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_SPECIFIC_TOOL_CHOICE, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) if "name" not in kwargs: kwargs["name"] = "" return kwargs @@ -12463,10 +11541,11 @@ class ToolChoiceAuto: value: AutoToolChoice def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_TOOL_CHOICE, self) + serializer.write_struct(hydrate(_SCHEMA_TOOL_CHOICE), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_TOOL_CHOICE.members["auto"], self.value) + members = hydrate(_SCHEMA_TOOL_CHOICE).members_by_index + serializer.write_struct(members[0], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -12480,10 +11559,11 @@ class ToolChoiceAny: value: AnyToolChoice def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_TOOL_CHOICE, self) + serializer.write_struct(hydrate(_SCHEMA_TOOL_CHOICE), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_TOOL_CHOICE.members["any"], self.value) + members = hydrate(_SCHEMA_TOOL_CHOICE).members_by_index + serializer.write_struct(members[1], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -12500,10 +11580,11 @@ class ToolChoiceTool: value: SpecificToolChoice def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_TOOL_CHOICE, self) + serializer.write_struct(hydrate(_SCHEMA_TOOL_CHOICE), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_TOOL_CHOICE.members["tool"], self.value) + members = hydrate(_SCHEMA_TOOL_CHOICE).members_by_index + serializer.write_struct(members[2], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -12549,7 +11630,7 @@ class _ToolChoiceDeserializer: def deserialize(self, deserializer: ShapeDeserializer) -> ToolChoice: self._result = None - deserializer.read_struct(_SCHEMA_TOOL_CHOICE, self._consumer) + deserializer.read_struct(hydrate(_SCHEMA_TOOL_CHOICE), self._consumer) if self._result is None: raise SerializationError( @@ -12591,10 +11672,11 @@ class SystemTool: """The name of the system-defined tool that you want to call.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_SYSTEM_TOOL, self) + serializer.write_struct(hydrate(_SCHEMA_SYSTEM_TOOL), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_string(_SCHEMA_SYSTEM_TOOL.members["name"], self.name) + members = hydrate(_SCHEMA_SYSTEM_TOOL).members_by_index + serializer.write_string(members[0], self.name) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -12603,16 +11685,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_SYSTEM_TOOL) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["name"] = de.read_string(_SCHEMA_SYSTEM_TOOL.members["name"]) + kwargs["name"] = de.read_string(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_SYSTEM_TOOL, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) if "name" not in kwargs: kwargs["name"] = "" return kwargs @@ -12628,16 +11712,16 @@ class ToolInputSchemaJson: value: Document def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_TOOL_INPUT_SCHEMA, self) + serializer.write_struct(hydrate(_SCHEMA_TOOL_INPUT_SCHEMA), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_document(_SCHEMA_TOOL_INPUT_SCHEMA.members["json"], self.value) + members = hydrate(_SCHEMA_TOOL_INPUT_SCHEMA).members_by_index + serializer.write_document(members[0], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: - return cls( - value=deserializer.read_document(_SCHEMA_TOOL_INPUT_SCHEMA.members["json"]) - ) + members = hydrate(_SCHEMA_TOOL_INPUT_SCHEMA).members_by_index + return cls(value=deserializer.read_document(members[0])) @dataclass @@ -12678,7 +11762,7 @@ class _ToolInputSchemaDeserializer: def deserialize(self, deserializer: ShapeDeserializer) -> ToolInputSchema: self._result = None - deserializer.read_struct(_SCHEMA_TOOL_INPUT_SCHEMA, self._consumer) + deserializer.read_struct(hydrate(_SCHEMA_TOOL_INPUT_SCHEMA), self._consumer) if self._result is None: raise SerializationError( @@ -12727,22 +11811,17 @@ class ToolSpecification: """Flag to enable structured output enforcement on a tool usage response.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_TOOL_SPECIFICATION, self) + serializer.write_struct(hydrate(_SCHEMA_TOOL_SPECIFICATION), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_string(_SCHEMA_TOOL_SPECIFICATION.members["name"], self.name) + members = hydrate(_SCHEMA_TOOL_SPECIFICATION).members_by_index + serializer.write_string(members[0], self.name) if self.description is not None: - serializer.write_string( - _SCHEMA_TOOL_SPECIFICATION.members["description"], self.description - ) + serializer.write_string(members[1], self.description) - serializer.write_struct( - _SCHEMA_TOOL_SPECIFICATION.members["inputSchema"], self.input_schema - ) + serializer.write_struct(members[2], self.input_schema) if self.strict is not None: - serializer.write_boolean( - _SCHEMA_TOOL_SPECIFICATION.members["strict"], self.strict - ) + serializer.write_boolean(members[3], self.strict) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -12751,18 +11830,16 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_TOOL_SPECIFICATION) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["name"] = de.read_string( - _SCHEMA_TOOL_SPECIFICATION.members["name"] - ) + kwargs["name"] = de.read_string(members[0]) case 1: - kwargs["description"] = de.read_string( - _SCHEMA_TOOL_SPECIFICATION.members["description"] - ) + kwargs["description"] = de.read_string(members[1]) case 2: kwargs["input_schema"] = _ToolInputSchemaDeserializer().deserialize( @@ -12770,14 +11847,12 @@ def _consumer(schema: Schema, de: ShapeDeserializer) -> None: ) case 3: - kwargs["strict"] = de.read_boolean( - _SCHEMA_TOOL_SPECIFICATION.members["strict"] - ) + kwargs["strict"] = de.read_boolean(members[3]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_TOOL_SPECIFICATION, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) if "name" not in kwargs: kwargs["name"] = "" if "input_schema" not in kwargs: @@ -12792,10 +11867,11 @@ class ToolToolSpec: value: ToolSpecification def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_TOOL, self) + serializer.write_struct(hydrate(_SCHEMA_TOOL), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_TOOL.members["toolSpec"], self.value) + members = hydrate(_SCHEMA_TOOL).members_by_index + serializer.write_struct(members[0], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -12809,10 +11885,11 @@ class ToolSystemTool: value: SystemTool def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_TOOL, self) + serializer.write_struct(hydrate(_SCHEMA_TOOL), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_TOOL.members["systemTool"], self.value) + members = hydrate(_SCHEMA_TOOL).members_by_index + serializer.write_struct(members[1], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -12826,10 +11903,11 @@ class ToolCachePoint: value: CachePointBlock def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_TOOL, self) + serializer.write_struct(hydrate(_SCHEMA_TOOL), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_TOOL.members["cachePoint"], self.value) + members = hydrate(_SCHEMA_TOOL).members_by_index + serializer.write_struct(members[2], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -12874,7 +11952,7 @@ class _ToolDeserializer: def deserialize(self, deserializer: ShapeDeserializer) -> Tool: self._result = None - deserializer.read_struct(_SCHEMA_TOOL, self._consumer) + deserializer.read_struct(hydrate(_SCHEMA_TOOL), self._consumer) if self._result is None: raise SerializationError( @@ -12908,7 +11986,7 @@ def _set_result(self, value: Tool) -> None: def _serialize_tools( serializer: ShapeSerializer, schema: Schema, value: list[Tool] ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_struct(member_schema, e) @@ -12944,16 +12022,13 @@ class ToolConfiguration: """If supported by model, forces the model to request a tool.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_TOOL_CONFIGURATION, self) + serializer.write_struct(hydrate(_SCHEMA_TOOL_CONFIGURATION), self) def serialize_members(self, serializer: ShapeSerializer): - _serialize_tools( - serializer, _SCHEMA_TOOL_CONFIGURATION.members["tools"], self.tools - ) + members = hydrate(_SCHEMA_TOOL_CONFIGURATION).members_by_index + _serialize_tools(serializer, members[0], self.tools) if self.tool_choice is not None: - serializer.write_struct( - _SCHEMA_TOOL_CONFIGURATION.members["toolChoice"], self.tool_choice - ) + serializer.write_struct(members[1], self.tool_choice) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -12962,21 +12037,21 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_TOOL_CONFIGURATION) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["tools"] = _deserialize_tools( - de, _SCHEMA_TOOL_CONFIGURATION.members["tools"] - ) + kwargs["tools"] = _deserialize_tools(de, members[0]) case 1: kwargs["tool_choice"] = _ToolChoiceDeserializer().deserialize(de) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_TOOL_CONFIGURATION, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) if "tools" not in kwargs: kwargs["tools"] = [] return kwargs @@ -13114,81 +12189,52 @@ class ConverseInput: """Output configuration for a model response.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_CONVERSE_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_CONVERSE_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_CONVERSE_INPUT).members_by_index if self.model_id is not None: - serializer.write_string( - _SCHEMA_CONVERSE_INPUT.members["modelId"], self.model_id - ) + serializer.write_string(members[0], self.model_id) if self.messages is not None: - _serialize_messages( - serializer, _SCHEMA_CONVERSE_INPUT.members["messages"], self.messages - ) + _serialize_messages(serializer, members[1], self.messages) if self.system is not None: - _serialize_system_content_blocks( - serializer, _SCHEMA_CONVERSE_INPUT.members["system"], self.system - ) + _serialize_system_content_blocks(serializer, members[2], self.system) if self.inference_config is not None: - serializer.write_struct( - _SCHEMA_CONVERSE_INPUT.members["inferenceConfig"], self.inference_config - ) + serializer.write_struct(members[3], self.inference_config) if self.tool_config is not None: - serializer.write_struct( - _SCHEMA_CONVERSE_INPUT.members["toolConfig"], self.tool_config - ) + serializer.write_struct(members[4], self.tool_config) if self.guardrail_config is not None: - serializer.write_struct( - _SCHEMA_CONVERSE_INPUT.members["guardrailConfig"], self.guardrail_config - ) + serializer.write_struct(members[5], self.guardrail_config) if self.additional_model_request_fields is not None: - serializer.write_document( - _SCHEMA_CONVERSE_INPUT.members["additionalModelRequestFields"], - self.additional_model_request_fields, - ) + serializer.write_document(members[6], self.additional_model_request_fields) if self.prompt_variables is not None: _serialize_prompt_variable_map( - serializer, - _SCHEMA_CONVERSE_INPUT.members["promptVariables"], - self.prompt_variables, + serializer, members[7], self.prompt_variables ) if self.additional_model_response_field_paths is not None: _serialize_additional_model_response_field_paths( - serializer, - _SCHEMA_CONVERSE_INPUT.members["additionalModelResponseFieldPaths"], - self.additional_model_response_field_paths, + serializer, members[8], self.additional_model_response_field_paths ) if self.request_metadata is not None: - _serialize_request_metadata( - serializer, - _SCHEMA_CONVERSE_INPUT.members["requestMetadata"], - self.request_metadata, - ) + _serialize_request_metadata(serializer, members[9], self.request_metadata) if self.performance_config is not None: - serializer.write_struct( - _SCHEMA_CONVERSE_INPUT.members["performanceConfig"], - self.performance_config, - ) + serializer.write_struct(members[10], self.performance_config) if self.service_tier is not None: - serializer.write_struct( - _SCHEMA_CONVERSE_INPUT.members["serviceTier"], self.service_tier - ) + serializer.write_struct(members[11], self.service_tier) if self.output_config is not None: - serializer.write_struct( - _SCHEMA_CONVERSE_INPUT.members["outputConfig"], self.output_config - ) + serializer.write_struct(members[12], self.output_config) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -13197,22 +12243,20 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_CONVERSE_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["model_id"] = de.read_string( - _SCHEMA_CONVERSE_INPUT.members["modelId"] - ) + kwargs["model_id"] = de.read_string(members[0]) case 1: - kwargs["messages"] = _deserialize_messages( - de, _SCHEMA_CONVERSE_INPUT.members["messages"] - ) + kwargs["messages"] = _deserialize_messages(de, members[1]) case 2: kwargs["system"] = _deserialize_system_content_blocks( - de, _SCHEMA_CONVERSE_INPUT.members["system"] + de, members[2] ) case 3: @@ -13226,27 +12270,24 @@ def _consumer(schema: Schema, de: ShapeDeserializer) -> None: case 6: kwargs["additional_model_request_fields"] = de.read_document( - _SCHEMA_CONVERSE_INPUT.members["additionalModelRequestFields"] + members[6] ) case 7: kwargs["prompt_variables"] = _deserialize_prompt_variable_map( - de, _SCHEMA_CONVERSE_INPUT.members["promptVariables"] + de, members[7] ) case 8: kwargs["additional_model_response_field_paths"] = ( _deserialize_additional_model_response_field_paths( - de, - _SCHEMA_CONVERSE_INPUT.members[ - "additionalModelResponseFieldPaths" - ], + de, members[8] ) ) case 9: kwargs["request_metadata"] = _deserialize_request_metadata( - de, _SCHEMA_CONVERSE_INPUT.members["requestMetadata"] + de, members[9] ) case 10: @@ -13261,9 +12302,9 @@ def _consumer(schema: Schema, de: ShapeDeserializer) -> None: kwargs["output_config"] = OutputConfig.deserialize(de) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_CONVERSE_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -13278,12 +12319,11 @@ class ConverseMetrics: """The latency of the call to `Converse`, in milliseconds.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_CONVERSE_METRICS, self) + serializer.write_struct(hydrate(_SCHEMA_CONVERSE_METRICS), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_long( - _SCHEMA_CONVERSE_METRICS.members["latencyMs"], self.latency_ms - ) + members = hydrate(_SCHEMA_CONVERSE_METRICS).members_by_index + serializer.write_long(members[0], self.latency_ms) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -13292,18 +12332,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_CONVERSE_METRICS) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["latency_ms"] = de.read_long( - _SCHEMA_CONVERSE_METRICS.members["latencyMs"] - ) + kwargs["latency_ms"] = de.read_long(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_CONVERSE_METRICS, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) if "latency_ms" not in kwargs: kwargs["latency_ms"] = 0 return kwargs @@ -13320,10 +12360,11 @@ class ConverseOutputMessage: value: Message def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_CONVERSE_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_CONVERSE_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_CONVERSE_OUTPUT.members["message"], self.value) + members = hydrate(_SCHEMA_CONVERSE_OUTPUT).members_by_index + serializer.write_struct(members[0], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -13366,7 +12407,7 @@ class _ConverseOutputDeserializer: def deserialize(self, deserializer: ShapeDeserializer) -> ConverseOutput: self._result = None - deserializer.read_struct(_SCHEMA_CONVERSE_OUTPUT, self._consumer) + deserializer.read_struct(hydrate(_SCHEMA_CONVERSE_OUTPUT), self._consumer) if self._result is None: raise SerializationError( @@ -13407,7 +12448,7 @@ def _serialize_guardrail_assessment_map( serializer: ShapeSerializer, schema: Schema, value: dict[str, GuardrailAssessment] ) -> None: with serializer.begin_map(schema, len(value)) as m: - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] for k, v in value.items(): m.entry(k, lambda vs: vs.write_struct(value_schema, v)) @@ -13416,7 +12457,7 @@ def _deserialize_guardrail_assessment_map( deserializer: ShapeDeserializer, schema: Schema ) -> dict[str, GuardrailAssessment]: result: dict[str, GuardrailAssessment] = {} - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] def _read_value(k: str, d: ShapeDeserializer): if d.is_null(): @@ -13432,7 +12473,7 @@ def _read_value(k: str, d: ShapeDeserializer): def _serialize_model_outputs( serializer: ShapeSerializer, schema: Schema, value: list[str] ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_string(member_schema, e) @@ -13442,7 +12483,7 @@ def _deserialize_model_outputs( deserializer: ShapeDeserializer, schema: Schema ) -> list[str]: result: list[str] = [] - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] def _read_value(d: ShapeDeserializer): if d.is_null(): @@ -13461,7 +12502,7 @@ def _serialize_guardrail_assessment_list_map( value: dict[str, list[GuardrailAssessment]], ) -> None: with serializer.begin_map(schema, len(value)) as m: - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] for k, v in value.items(): m.entry( k, lambda vs: _serialize_guardrail_assessment_list(vs, value_schema, v) @@ -13472,7 +12513,7 @@ def _deserialize_guardrail_assessment_list_map( deserializer: ShapeDeserializer, schema: Schema ) -> dict[str, list[GuardrailAssessment]]: result: dict[str, list[GuardrailAssessment]] = {} - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] def _read_value(k: str, d: ShapeDeserializer): if d.is_null(): @@ -13508,35 +12549,25 @@ class GuardrailTraceAssessment: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_GUARDRAIL_TRACE_ASSESSMENT, self) + serializer.write_struct(hydrate(_SCHEMA_GUARDRAIL_TRACE_ASSESSMENT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_GUARDRAIL_TRACE_ASSESSMENT).members_by_index if self.model_output is not None: - _serialize_model_outputs( - serializer, - _SCHEMA_GUARDRAIL_TRACE_ASSESSMENT.members["modelOutput"], - self.model_output, - ) + _serialize_model_outputs(serializer, members[0], self.model_output) if self.input_assessment is not None: _serialize_guardrail_assessment_map( - serializer, - _SCHEMA_GUARDRAIL_TRACE_ASSESSMENT.members["inputAssessment"], - self.input_assessment, + serializer, members[1], self.input_assessment ) if self.output_assessments is not None: _serialize_guardrail_assessment_list_map( - serializer, - _SCHEMA_GUARDRAIL_TRACE_ASSESSMENT.members["outputAssessments"], - self.output_assessments, + serializer, members[2], self.output_assessments ) if self.action_reason is not None: - serializer.write_string( - _SCHEMA_GUARDRAIL_TRACE_ASSESSMENT.members["actionReason"], - self.action_reason, - ) + serializer.write_string(members[3], self.action_reason) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -13545,39 +12576,31 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_GUARDRAIL_TRACE_ASSESSMENT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["model_output"] = _deserialize_model_outputs( - de, _SCHEMA_GUARDRAIL_TRACE_ASSESSMENT.members["modelOutput"] - ) + kwargs["model_output"] = _deserialize_model_outputs(de, members[0]) case 1: kwargs["input_assessment"] = _deserialize_guardrail_assessment_map( - de, - _SCHEMA_GUARDRAIL_TRACE_ASSESSMENT.members["inputAssessment"], + de, members[1] ) case 2: kwargs["output_assessments"] = ( - _deserialize_guardrail_assessment_list_map( - de, - _SCHEMA_GUARDRAIL_TRACE_ASSESSMENT.members[ - "outputAssessments" - ], - ) + _deserialize_guardrail_assessment_list_map(de, members[2]) ) case 3: - kwargs["action_reason"] = de.read_string( - _SCHEMA_GUARDRAIL_TRACE_ASSESSMENT.members["actionReason"] - ) + kwargs["action_reason"] = de.read_string(members[3]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_GUARDRAIL_TRACE_ASSESSMENT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -13589,14 +12612,12 @@ class PromptRouterTrace: """The ID of the invoked model.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_PROMPT_ROUTER_TRACE, self) + serializer.write_struct(hydrate(_SCHEMA_PROMPT_ROUTER_TRACE), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_PROMPT_ROUTER_TRACE).members_by_index if self.invoked_model_id is not None: - serializer.write_string( - _SCHEMA_PROMPT_ROUTER_TRACE.members["invokedModelId"], - self.invoked_model_id, - ) + serializer.write_string(members[0], self.invoked_model_id) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -13605,18 +12626,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_PROMPT_ROUTER_TRACE) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["invoked_model_id"] = de.read_string( - _SCHEMA_PROMPT_ROUTER_TRACE.members["invokedModelId"] - ) + kwargs["invoked_model_id"] = de.read_string(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_PROMPT_ROUTER_TRACE, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -13634,18 +12655,15 @@ class ConverseTrace: """The request's prompt router.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_CONVERSE_TRACE, self) + serializer.write_struct(hydrate(_SCHEMA_CONVERSE_TRACE), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_CONVERSE_TRACE).members_by_index if self.guardrail is not None: - serializer.write_struct( - _SCHEMA_CONVERSE_TRACE.members["guardrail"], self.guardrail - ) + serializer.write_struct(members[0], self.guardrail) if self.prompt_router is not None: - serializer.write_struct( - _SCHEMA_CONVERSE_TRACE.members["promptRouter"], self.prompt_router - ) + serializer.write_struct(members[1], self.prompt_router) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -13654,9 +12672,11 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_CONVERSE_TRACE) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["guardrail"] = GuardrailTraceAssessment.deserialize(de) @@ -13664,9 +12684,9 @@ def _consumer(schema: Schema, de: ShapeDeserializer) -> None: kwargs["prompt_router"] = PromptRouterTrace.deserialize(de) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_CONVERSE_TRACE, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -13681,13 +12701,12 @@ class CacheDetail: """Number of tokens written to cache with this TTL (cache creation tokens)""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_CACHE_DETAIL, self) + serializer.write_struct(hydrate(_SCHEMA_CACHE_DETAIL), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_string(_SCHEMA_CACHE_DETAIL.members["ttl"], self.ttl) - serializer.write_integer( - _SCHEMA_CACHE_DETAIL.members["inputTokens"], self.input_tokens - ) + members = hydrate(_SCHEMA_CACHE_DETAIL).members_by_index + serializer.write_string(members[0], self.ttl) + serializer.write_integer(members[1], self.input_tokens) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -13696,23 +12715,21 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_CACHE_DETAIL) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["ttl"] = CacheTTL( - de.read_string(_SCHEMA_CACHE_DETAIL.members["ttl"]) - ) + kwargs["ttl"] = CacheTTL(de.read_string(members[0])) case 1: - kwargs["input_tokens"] = de.read_integer( - _SCHEMA_CACHE_DETAIL.members["inputTokens"] - ) + kwargs["input_tokens"] = de.read_integer(members[1]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_CACHE_DETAIL, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) if "ttl" not in kwargs: kwargs["ttl"] = CacheTTL._corrected("") if "input_tokens" not in kwargs: @@ -13723,7 +12740,7 @@ def _consumer(schema: Schema, de: ShapeDeserializer) -> None: def _serialize_cache_details_list( serializer: ShapeSerializer, schema: Schema, value: list[CacheDetail] ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_struct(member_schema, e) @@ -13771,36 +12788,21 @@ class TokenUsage: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_TOKEN_USAGE, self) + serializer.write_struct(hydrate(_SCHEMA_TOKEN_USAGE), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_integer( - _SCHEMA_TOKEN_USAGE.members["inputTokens"], self.input_tokens - ) - serializer.write_integer( - _SCHEMA_TOKEN_USAGE.members["outputTokens"], self.output_tokens - ) - serializer.write_integer( - _SCHEMA_TOKEN_USAGE.members["totalTokens"], self.total_tokens - ) + members = hydrate(_SCHEMA_TOKEN_USAGE).members_by_index + serializer.write_integer(members[0], self.input_tokens) + serializer.write_integer(members[1], self.output_tokens) + serializer.write_integer(members[2], self.total_tokens) if self.cache_read_input_tokens is not None: - serializer.write_integer( - _SCHEMA_TOKEN_USAGE.members["cacheReadInputTokens"], - self.cache_read_input_tokens, - ) + serializer.write_integer(members[3], self.cache_read_input_tokens) if self.cache_write_input_tokens is not None: - serializer.write_integer( - _SCHEMA_TOKEN_USAGE.members["cacheWriteInputTokens"], - self.cache_write_input_tokens, - ) + serializer.write_integer(members[4], self.cache_write_input_tokens) if self.cache_details is not None: - _serialize_cache_details_list( - serializer, - _SCHEMA_TOKEN_USAGE.members["cacheDetails"], - self.cache_details, - ) + _serialize_cache_details_list(serializer, members[5], self.cache_details) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -13809,43 +12811,35 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_TOKEN_USAGE) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["input_tokens"] = de.read_integer( - _SCHEMA_TOKEN_USAGE.members["inputTokens"] - ) + kwargs["input_tokens"] = de.read_integer(members[0]) case 1: - kwargs["output_tokens"] = de.read_integer( - _SCHEMA_TOKEN_USAGE.members["outputTokens"] - ) + kwargs["output_tokens"] = de.read_integer(members[1]) case 2: - kwargs["total_tokens"] = de.read_integer( - _SCHEMA_TOKEN_USAGE.members["totalTokens"] - ) + kwargs["total_tokens"] = de.read_integer(members[2]) case 3: - kwargs["cache_read_input_tokens"] = de.read_integer( - _SCHEMA_TOKEN_USAGE.members["cacheReadInputTokens"] - ) + kwargs["cache_read_input_tokens"] = de.read_integer(members[3]) case 4: - kwargs["cache_write_input_tokens"] = de.read_integer( - _SCHEMA_TOKEN_USAGE.members["cacheWriteInputTokens"] - ) + kwargs["cache_write_input_tokens"] = de.read_integer(members[4]) case 5: kwargs["cache_details"] = _deserialize_cache_details_list( - de, _SCHEMA_TOKEN_USAGE.members["cacheDetails"] + de, members[5] ) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_TOKEN_USAGE, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) if "input_tokens" not in kwargs: kwargs["input_tokens"] = 0 if "output_tokens" not in kwargs: @@ -13905,45 +12899,25 @@ class ConverseOperationOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_CONVERSE_OPERATION_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_CONVERSE_OPERATION_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_struct( - _SCHEMA_CONVERSE_OPERATION_OUTPUT.members["output"], self.output - ) - serializer.write_string( - _SCHEMA_CONVERSE_OPERATION_OUTPUT.members["stopReason"], self.stop_reason - ) - serializer.write_struct( - _SCHEMA_CONVERSE_OPERATION_OUTPUT.members["usage"], self.usage - ) - serializer.write_struct( - _SCHEMA_CONVERSE_OPERATION_OUTPUT.members["metrics"], self.metrics - ) + members = hydrate(_SCHEMA_CONVERSE_OPERATION_OUTPUT).members_by_index + serializer.write_struct(members[0], self.output) + serializer.write_string(members[1], self.stop_reason) + serializer.write_struct(members[2], self.usage) + serializer.write_struct(members[3], self.metrics) if self.additional_model_response_fields is not None: - serializer.write_document( - _SCHEMA_CONVERSE_OPERATION_OUTPUT.members[ - "additionalModelResponseFields" - ], - self.additional_model_response_fields, - ) + serializer.write_document(members[4], self.additional_model_response_fields) if self.trace is not None: - serializer.write_struct( - _SCHEMA_CONVERSE_OPERATION_OUTPUT.members["trace"], self.trace - ) + serializer.write_struct(members[5], self.trace) if self.performance_config is not None: - serializer.write_struct( - _SCHEMA_CONVERSE_OPERATION_OUTPUT.members["performanceConfig"], - self.performance_config, - ) + serializer.write_struct(members[6], self.performance_config) if self.service_tier is not None: - serializer.write_struct( - _SCHEMA_CONVERSE_OPERATION_OUTPUT.members["serviceTier"], - self.service_tier, - ) + serializer.write_struct(members[7], self.service_tier) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -13952,18 +12926,16 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_CONVERSE_OPERATION_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["output"] = _ConverseOutputDeserializer().deserialize(de) case 1: - kwargs["stop_reason"] = StopReason( - de.read_string( - _SCHEMA_CONVERSE_OPERATION_OUTPUT.members["stopReason"] - ) - ) + kwargs["stop_reason"] = StopReason(de.read_string(members[1])) case 2: kwargs["usage"] = TokenUsage.deserialize(de) @@ -13973,9 +12945,7 @@ def _consumer(schema: Schema, de: ShapeDeserializer) -> None: case 4: kwargs["additional_model_response_fields"] = de.read_document( - _SCHEMA_CONVERSE_OPERATION_OUTPUT.members[ - "additionalModelResponseFields" - ] + members[4] ) case 5: @@ -13990,9 +12960,9 @@ def _consumer(schema: Schema, de: ShapeDeserializer) -> None: kwargs["service_tier"] = ServiceTier.deserialize(de) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_CONVERSE_OPERATION_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) if "output" not in kwargs: kwargs["output"] = ConverseOutputUnknown(tag="") if "stop_reason" not in kwargs: @@ -14017,25 +12987,18 @@ class ModelErrorException(ServiceError): """The resource name.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_MODEL_ERROR_EXCEPTION, self) + serializer.write_struct(hydrate(_SCHEMA_MODEL_ERROR_EXCEPTION), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_MODEL_ERROR_EXCEPTION).members_by_index if self.message is not None: - serializer.write_string( - _SCHEMA_MODEL_ERROR_EXCEPTION.members["message"], self.message - ) + serializer.write_string(members[0], self.message) if self.original_status_code is not None: - serializer.write_integer( - _SCHEMA_MODEL_ERROR_EXCEPTION.members["originalStatusCode"], - self.original_status_code, - ) + serializer.write_integer(members[1], self.original_status_code) if self.resource_name is not None: - serializer.write_string( - _SCHEMA_MODEL_ERROR_EXCEPTION.members["resourceName"], - self.resource_name, - ) + serializer.write_string(members[2], self.resource_name) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -14044,28 +13007,24 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_MODEL_ERROR_EXCEPTION) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["message"] = de.read_string( - _SCHEMA_MODEL_ERROR_EXCEPTION.members["message"] - ) + kwargs["message"] = de.read_string(members[0]) case 1: - kwargs["original_status_code"] = de.read_integer( - _SCHEMA_MODEL_ERROR_EXCEPTION.members["originalStatusCode"] - ) + kwargs["original_status_code"] = de.read_integer(members[1]) case 2: - kwargs["resource_name"] = de.read_string( - _SCHEMA_MODEL_ERROR_EXCEPTION.members["resourceName"] - ) + kwargs["resource_name"] = de.read_string(members[2]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_MODEL_ERROR_EXCEPTION, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -14083,13 +13042,12 @@ class ModelNotReadyException(ServiceError): is_retry_safe: bool | None = True def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_MODEL_NOT_READY_EXCEPTION, self) + serializer.write_struct(hydrate(_SCHEMA_MODEL_NOT_READY_EXCEPTION), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_MODEL_NOT_READY_EXCEPTION).members_by_index if self.message is not None: - serializer.write_string( - _SCHEMA_MODEL_NOT_READY_EXCEPTION.members["message"], self.message - ) + serializer.write_string(members[0], self.message) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -14098,18 +13056,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_MODEL_NOT_READY_EXCEPTION) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["message"] = de.read_string( - _SCHEMA_MODEL_NOT_READY_EXCEPTION.members["message"] - ) + kwargs["message"] = de.read_string(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_MODEL_NOT_READY_EXCEPTION, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -14123,13 +13081,12 @@ class ModelTimeoutException(ServiceError): fault: Literal["client", "server"] | None = "client" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_MODEL_TIMEOUT_EXCEPTION, self) + serializer.write_struct(hydrate(_SCHEMA_MODEL_TIMEOUT_EXCEPTION), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_MODEL_TIMEOUT_EXCEPTION).members_by_index if self.message is not None: - serializer.write_string( - _SCHEMA_MODEL_TIMEOUT_EXCEPTION.members["message"], self.message - ) + serializer.write_string(members[0], self.message) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -14138,27 +13095,25 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_MODEL_TIMEOUT_EXCEPTION) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["message"] = de.read_string( - _SCHEMA_MODEL_TIMEOUT_EXCEPTION.members["message"] - ) + kwargs["message"] = de.read_string(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_MODEL_TIMEOUT_EXCEPTION, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs CONVERSE = APIOperation( input=ConverseInput, output=ConverseOperationOutput, - schema=_SCHEMA_CONVERSE, - input_schema=_SCHEMA_CONVERSE_INPUT, - output_schema=_SCHEMA_CONVERSE_OPERATION_OUTPUT, + static_schema=_SCHEMA_CONVERSE, error_registry=TypeRegistry( { ShapeID( @@ -14194,17 +13149,6 @@ def _consumer(schema: Schema, de: ShapeDeserializer) -> None: ShapeID("aws.auth#sigv4"), ShapeID("smithy.api#httpBearerAuth"), ], - error_schemas=[ - _SCHEMA_ACCESS_DENIED_EXCEPTION, - _SCHEMA_INTERNAL_SERVER_EXCEPTION, - _SCHEMA_MODEL_ERROR_EXCEPTION, - _SCHEMA_MODEL_NOT_READY_EXCEPTION, - _SCHEMA_MODEL_TIMEOUT_EXCEPTION, - _SCHEMA_RESOURCE_NOT_FOUND_EXCEPTION, - _SCHEMA_SERVICE_UNAVAILABLE_EXCEPTION, - _SCHEMA_THROTTLING_EXCEPTION, - _SCHEMA_VALIDATION_EXCEPTION, - ], ) @@ -14239,24 +13183,14 @@ class GuardrailStreamConfiguration: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_GUARDRAIL_STREAM_CONFIGURATION, self) + serializer.write_struct(hydrate(_SCHEMA_GUARDRAIL_STREAM_CONFIGURATION), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_string( - _SCHEMA_GUARDRAIL_STREAM_CONFIGURATION.members["guardrailIdentifier"], - self.guardrail_identifier, - ) - serializer.write_string( - _SCHEMA_GUARDRAIL_STREAM_CONFIGURATION.members["guardrailVersion"], - self.guardrail_version, - ) - serializer.write_string( - _SCHEMA_GUARDRAIL_STREAM_CONFIGURATION.members["trace"], self.trace - ) - serializer.write_string( - _SCHEMA_GUARDRAIL_STREAM_CONFIGURATION.members["streamProcessingMode"], - self.stream_processing_mode, - ) + members = hydrate(_SCHEMA_GUARDRAIL_STREAM_CONFIGURATION).members_by_index + serializer.write_string(members[0], self.guardrail_identifier) + serializer.write_string(members[1], self.guardrail_version) + serializer.write_string(members[2], self.trace) + serializer.write_string(members[3], self.stream_processing_mode) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -14265,45 +13199,29 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_GUARDRAIL_STREAM_CONFIGURATION) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["guardrail_identifier"] = de.read_string( - _SCHEMA_GUARDRAIL_STREAM_CONFIGURATION.members[ - "guardrailIdentifier" - ] - ) + kwargs["guardrail_identifier"] = de.read_string(members[0]) case 1: - kwargs["guardrail_version"] = de.read_string( - _SCHEMA_GUARDRAIL_STREAM_CONFIGURATION.members[ - "guardrailVersion" - ] - ) + kwargs["guardrail_version"] = de.read_string(members[1]) case 2: - kwargs["trace"] = GuardrailTrace( - de.read_string( - _SCHEMA_GUARDRAIL_STREAM_CONFIGURATION.members["trace"] - ) - ) + kwargs["trace"] = GuardrailTrace(de.read_string(members[2])) case 3: kwargs["stream_processing_mode"] = GuardrailStreamProcessingMode( - de.read_string( - _SCHEMA_GUARDRAIL_STREAM_CONFIGURATION.members[ - "streamProcessingMode" - ] - ) + de.read_string(members[3]) ) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_GUARDRAIL_STREAM_CONFIGURATION, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -14439,88 +13357,52 @@ class ConverseStreamInput: """Output configuration for a model response.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_CONVERSE_STREAM_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_CONVERSE_STREAM_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_CONVERSE_STREAM_INPUT).members_by_index if self.model_id is not None: - serializer.write_string( - _SCHEMA_CONVERSE_STREAM_INPUT.members["modelId"], self.model_id - ) + serializer.write_string(members[0], self.model_id) if self.messages is not None: - _serialize_messages( - serializer, - _SCHEMA_CONVERSE_STREAM_INPUT.members["messages"], - self.messages, - ) + _serialize_messages(serializer, members[1], self.messages) if self.system is not None: - _serialize_system_content_blocks( - serializer, _SCHEMA_CONVERSE_STREAM_INPUT.members["system"], self.system - ) + _serialize_system_content_blocks(serializer, members[2], self.system) if self.inference_config is not None: - serializer.write_struct( - _SCHEMA_CONVERSE_STREAM_INPUT.members["inferenceConfig"], - self.inference_config, - ) + serializer.write_struct(members[3], self.inference_config) if self.tool_config is not None: - serializer.write_struct( - _SCHEMA_CONVERSE_STREAM_INPUT.members["toolConfig"], self.tool_config - ) + serializer.write_struct(members[4], self.tool_config) if self.guardrail_config is not None: - serializer.write_struct( - _SCHEMA_CONVERSE_STREAM_INPUT.members["guardrailConfig"], - self.guardrail_config, - ) + serializer.write_struct(members[5], self.guardrail_config) if self.additional_model_request_fields is not None: - serializer.write_document( - _SCHEMA_CONVERSE_STREAM_INPUT.members["additionalModelRequestFields"], - self.additional_model_request_fields, - ) + serializer.write_document(members[6], self.additional_model_request_fields) if self.prompt_variables is not None: _serialize_prompt_variable_map( - serializer, - _SCHEMA_CONVERSE_STREAM_INPUT.members["promptVariables"], - self.prompt_variables, + serializer, members[7], self.prompt_variables ) if self.additional_model_response_field_paths is not None: _serialize_additional_model_response_field_paths( - serializer, - _SCHEMA_CONVERSE_STREAM_INPUT.members[ - "additionalModelResponseFieldPaths" - ], - self.additional_model_response_field_paths, + serializer, members[8], self.additional_model_response_field_paths ) if self.request_metadata is not None: - _serialize_request_metadata( - serializer, - _SCHEMA_CONVERSE_STREAM_INPUT.members["requestMetadata"], - self.request_metadata, - ) + _serialize_request_metadata(serializer, members[9], self.request_metadata) if self.performance_config is not None: - serializer.write_struct( - _SCHEMA_CONVERSE_STREAM_INPUT.members["performanceConfig"], - self.performance_config, - ) + serializer.write_struct(members[10], self.performance_config) if self.service_tier is not None: - serializer.write_struct( - _SCHEMA_CONVERSE_STREAM_INPUT.members["serviceTier"], self.service_tier - ) + serializer.write_struct(members[11], self.service_tier) if self.output_config is not None: - serializer.write_struct( - _SCHEMA_CONVERSE_STREAM_INPUT.members["outputConfig"], - self.output_config, - ) + serializer.write_struct(members[12], self.output_config) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -14529,22 +13411,20 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_CONVERSE_STREAM_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["model_id"] = de.read_string( - _SCHEMA_CONVERSE_STREAM_INPUT.members["modelId"] - ) + kwargs["model_id"] = de.read_string(members[0]) case 1: - kwargs["messages"] = _deserialize_messages( - de, _SCHEMA_CONVERSE_STREAM_INPUT.members["messages"] - ) + kwargs["messages"] = _deserialize_messages(de, members[1]) case 2: kwargs["system"] = _deserialize_system_content_blocks( - de, _SCHEMA_CONVERSE_STREAM_INPUT.members["system"] + de, members[2] ) case 3: @@ -14560,29 +13440,24 @@ def _consumer(schema: Schema, de: ShapeDeserializer) -> None: case 6: kwargs["additional_model_request_fields"] = de.read_document( - _SCHEMA_CONVERSE_STREAM_INPUT.members[ - "additionalModelRequestFields" - ] + members[6] ) case 7: kwargs["prompt_variables"] = _deserialize_prompt_variable_map( - de, _SCHEMA_CONVERSE_STREAM_INPUT.members["promptVariables"] + de, members[7] ) case 8: kwargs["additional_model_response_field_paths"] = ( _deserialize_additional_model_response_field_paths( - de, - _SCHEMA_CONVERSE_STREAM_INPUT.members[ - "additionalModelResponseFieldPaths" - ], + de, members[8] ) ) case 9: kwargs["request_metadata"] = _deserialize_request_metadata( - de, _SCHEMA_CONVERSE_STREAM_INPUT.members["requestMetadata"] + de, members[9] ) case 10: @@ -14597,9 +13472,9 @@ def _consumer(schema: Schema, de: ShapeDeserializer) -> None: kwargs["output_config"] = OutputConfig.deserialize(de) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_CONVERSE_STREAM_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -14617,13 +13492,12 @@ class CitationSourceContentDelta: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_CITATION_SOURCE_CONTENT_DELTA, self) + serializer.write_struct(hydrate(_SCHEMA_CITATION_SOURCE_CONTENT_DELTA), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_CITATION_SOURCE_CONTENT_DELTA).members_by_index if self.text is not None: - serializer.write_string( - _SCHEMA_CITATION_SOURCE_CONTENT_DELTA.members["text"], self.text - ) + serializer.write_string(members[0], self.text) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -14632,27 +13506,25 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_CITATION_SOURCE_CONTENT_DELTA) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["text"] = de.read_string( - _SCHEMA_CITATION_SOURCE_CONTENT_DELTA.members["text"] - ) + kwargs["text"] = de.read_string(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_CITATION_SOURCE_CONTENT_DELTA, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs def _serialize_citation_source_content_list_delta( serializer: ShapeSerializer, schema: Schema, value: list[CitationSourceContentDelta] ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_struct(member_schema, e) @@ -14706,30 +13578,23 @@ class CitationsDelta: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_CITATIONS_DELTA, self) + serializer.write_struct(hydrate(_SCHEMA_CITATIONS_DELTA), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_CITATIONS_DELTA).members_by_index if self.title is not None: - serializer.write_string( - _SCHEMA_CITATIONS_DELTA.members["title"], self.title - ) + serializer.write_string(members[0], self.title) if self.source is not None: - serializer.write_string( - _SCHEMA_CITATIONS_DELTA.members["source"], self.source - ) + serializer.write_string(members[1], self.source) if self.source_content is not None: _serialize_citation_source_content_list_delta( - serializer, - _SCHEMA_CITATIONS_DELTA.members["sourceContent"], - self.source_content, + serializer, members[2], self.source_content ) if self.location is not None: - serializer.write_struct( - _SCHEMA_CITATIONS_DELTA.members["location"], self.location - ) + serializer.write_struct(members[3], self.location) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -14738,33 +13603,29 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_CITATIONS_DELTA) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["title"] = de.read_string( - _SCHEMA_CITATIONS_DELTA.members["title"] - ) + kwargs["title"] = de.read_string(members[0]) case 1: - kwargs["source"] = de.read_string( - _SCHEMA_CITATIONS_DELTA.members["source"] - ) + kwargs["source"] = de.read_string(members[1]) case 2: kwargs["source_content"] = ( - _deserialize_citation_source_content_list_delta( - de, _SCHEMA_CITATIONS_DELTA.members["sourceContent"] - ) + _deserialize_citation_source_content_list_delta(de, members[2]) ) case 3: kwargs["location"] = _CitationLocationDeserializer().deserialize(de) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_CITATIONS_DELTA, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -14782,18 +13643,15 @@ class ImageBlockDelta: """Error information if this image delta could not be processed.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_IMAGE_BLOCK_DELTA, self) + serializer.write_struct(hydrate(_SCHEMA_IMAGE_BLOCK_DELTA), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_IMAGE_BLOCK_DELTA).members_by_index if self.source is not None: - serializer.write_struct( - _SCHEMA_IMAGE_BLOCK_DELTA.members["source"], self.source - ) + serializer.write_struct(members[0], self.source) if self.error is not None: - serializer.write_struct( - _SCHEMA_IMAGE_BLOCK_DELTA.members["error"], self.error - ) + serializer.write_struct(members[1], self.error) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -14802,9 +13660,11 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_IMAGE_BLOCK_DELTA) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["source"] = _ImageSourceDeserializer().deserialize(de) @@ -14812,9 +13672,9 @@ def _consumer(schema: Schema, de: ShapeDeserializer) -> None: kwargs["error"] = ErrorBlock.deserialize(de) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_IMAGE_BLOCK_DELTA, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -14825,20 +13685,16 @@ class ReasoningContentBlockDeltaText: value: str def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_REASONING_CONTENT_BLOCK_DELTA, self) + serializer.write_struct(hydrate(_SCHEMA_REASONING_CONTENT_BLOCK_DELTA), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_string( - _SCHEMA_REASONING_CONTENT_BLOCK_DELTA.members["text"], self.value - ) + members = hydrate(_SCHEMA_REASONING_CONTENT_BLOCK_DELTA).members_by_index + serializer.write_string(members[0], self.value) @classmethod - def deserialize(cls, deserializer: ShapeDeserializer) -> Self: - return cls( - value=deserializer.read_string( - _SCHEMA_REASONING_CONTENT_BLOCK_DELTA.members["text"] - ) - ) + def deserialize(cls, deserializer: ShapeDeserializer) -> Self: + members = hydrate(_SCHEMA_REASONING_CONTENT_BLOCK_DELTA).members_by_index + return cls(value=deserializer.read_string(members[0])) @dataclass @@ -14852,20 +13708,16 @@ class ReasoningContentBlockDeltaRedactedContent: value: bytes def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_REASONING_CONTENT_BLOCK_DELTA, self) + serializer.write_struct(hydrate(_SCHEMA_REASONING_CONTENT_BLOCK_DELTA), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_blob( - _SCHEMA_REASONING_CONTENT_BLOCK_DELTA.members["redactedContent"], self.value - ) + members = hydrate(_SCHEMA_REASONING_CONTENT_BLOCK_DELTA).members_by_index + serializer.write_blob(members[1], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: - return cls( - value=deserializer.read_blob( - _SCHEMA_REASONING_CONTENT_BLOCK_DELTA.members["redactedContent"] - ) - ) + members = hydrate(_SCHEMA_REASONING_CONTENT_BLOCK_DELTA).members_by_index + return cls(value=deserializer.read_blob(members[1])) @dataclass @@ -14879,20 +13731,16 @@ class ReasoningContentBlockDeltaSignature: value: str def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_REASONING_CONTENT_BLOCK_DELTA, self) + serializer.write_struct(hydrate(_SCHEMA_REASONING_CONTENT_BLOCK_DELTA), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_string( - _SCHEMA_REASONING_CONTENT_BLOCK_DELTA.members["signature"], self.value - ) + members = hydrate(_SCHEMA_REASONING_CONTENT_BLOCK_DELTA).members_by_index + serializer.write_string(members[2], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: - return cls( - value=deserializer.read_string( - _SCHEMA_REASONING_CONTENT_BLOCK_DELTA.members["signature"] - ) - ) + members = hydrate(_SCHEMA_REASONING_CONTENT_BLOCK_DELTA).members_by_index + return cls(value=deserializer.read_string(members[2])) @dataclass @@ -14940,7 +13788,9 @@ def deserialize( self, deserializer: ShapeDeserializer ) -> ReasoningContentBlockDelta: self._result = None - deserializer.read_struct(_SCHEMA_REASONING_CONTENT_BLOCK_DELTA, self._consumer) + deserializer.read_struct( + hydrate(_SCHEMA_REASONING_CONTENT_BLOCK_DELTA), self._consumer + ) if self._result is None: raise SerializationError( @@ -14982,20 +13832,16 @@ class ToolResultBlockDeltaText: value: str def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_TOOL_RESULT_BLOCK_DELTA, self) + serializer.write_struct(hydrate(_SCHEMA_TOOL_RESULT_BLOCK_DELTA), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_string( - _SCHEMA_TOOL_RESULT_BLOCK_DELTA.members["text"], self.value - ) + members = hydrate(_SCHEMA_TOOL_RESULT_BLOCK_DELTA).members_by_index + serializer.write_string(members[0], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: - return cls( - value=deserializer.read_string( - _SCHEMA_TOOL_RESULT_BLOCK_DELTA.members["text"] - ) - ) + members = hydrate(_SCHEMA_TOOL_RESULT_BLOCK_DELTA).members_by_index + return cls(value=deserializer.read_string(members[0])) @dataclass @@ -15008,20 +13854,16 @@ class ToolResultBlockDeltaJson: value: Document def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_TOOL_RESULT_BLOCK_DELTA, self) + serializer.write_struct(hydrate(_SCHEMA_TOOL_RESULT_BLOCK_DELTA), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_document( - _SCHEMA_TOOL_RESULT_BLOCK_DELTA.members["json"], self.value - ) + members = hydrate(_SCHEMA_TOOL_RESULT_BLOCK_DELTA).members_by_index + serializer.write_document(members[1], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: - return cls( - value=deserializer.read_document( - _SCHEMA_TOOL_RESULT_BLOCK_DELTA.members["json"] - ) - ) + members = hydrate(_SCHEMA_TOOL_RESULT_BLOCK_DELTA).members_by_index + return cls(value=deserializer.read_document(members[1])) @dataclass @@ -15063,7 +13905,9 @@ class _ToolResultBlockDeltaDeserializer: def deserialize(self, deserializer: ShapeDeserializer) -> ToolResultBlockDelta: self._result = None - deserializer.read_struct(_SCHEMA_TOOL_RESULT_BLOCK_DELTA, self._consumer) + deserializer.read_struct( + hydrate(_SCHEMA_TOOL_RESULT_BLOCK_DELTA), self._consumer + ) if self._result is None: raise SerializationError( @@ -15096,7 +13940,7 @@ def _set_result(self, value: ToolResultBlockDelta) -> None: def _serialize_tool_result_blocks_delta( serializer: ShapeSerializer, schema: Schema, value: list[ToolResultBlockDelta] ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_struct(member_schema, e) @@ -15126,12 +13970,11 @@ class ToolUseBlockDelta: """The input for a requested tool.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_TOOL_USE_BLOCK_DELTA, self) + serializer.write_struct(hydrate(_SCHEMA_TOOL_USE_BLOCK_DELTA), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_string( - _SCHEMA_TOOL_USE_BLOCK_DELTA.members["input"], self.input - ) + members = hydrate(_SCHEMA_TOOL_USE_BLOCK_DELTA).members_by_index + serializer.write_string(members[0], self.input) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -15140,18 +13983,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_TOOL_USE_BLOCK_DELTA) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["input"] = de.read_string( - _SCHEMA_TOOL_USE_BLOCK_DELTA.members["input"] - ) + kwargs["input"] = de.read_string(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_TOOL_USE_BLOCK_DELTA, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) if "input" not in kwargs: kwargs["input"] = "" return kwargs @@ -15164,16 +14007,16 @@ class ContentBlockDeltaText: value: str def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_CONTENT_BLOCK_DELTA, self) + serializer.write_struct(hydrate(_SCHEMA_CONTENT_BLOCK_DELTA), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_string(_SCHEMA_CONTENT_BLOCK_DELTA.members["text"], self.value) + members = hydrate(_SCHEMA_CONTENT_BLOCK_DELTA).members_by_index + serializer.write_string(members[0], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: - return cls( - value=deserializer.read_string(_SCHEMA_CONTENT_BLOCK_DELTA.members["text"]) - ) + members = hydrate(_SCHEMA_CONTENT_BLOCK_DELTA).members_by_index + return cls(value=deserializer.read_string(members[0])) @dataclass @@ -15183,12 +14026,11 @@ class ContentBlockDeltaToolUse: value: ToolUseBlockDelta def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_CONTENT_BLOCK_DELTA, self) + serializer.write_struct(hydrate(_SCHEMA_CONTENT_BLOCK_DELTA), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_struct( - _SCHEMA_CONTENT_BLOCK_DELTA.members["toolUse"], self.value - ) + members = hydrate(_SCHEMA_CONTENT_BLOCK_DELTA).members_by_index + serializer.write_struct(members[1], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -15202,19 +14044,17 @@ class ContentBlockDeltaToolResult: value: list[ToolResultBlockDelta] def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_CONTENT_BLOCK_DELTA, self) + serializer.write_struct(hydrate(_SCHEMA_CONTENT_BLOCK_DELTA), self) def serialize_members(self, serializer: ShapeSerializer): - _serialize_tool_result_blocks_delta( - serializer, _SCHEMA_CONTENT_BLOCK_DELTA.members["toolResult"], self.value - ) + members = hydrate(_SCHEMA_CONTENT_BLOCK_DELTA).members_by_index + _serialize_tool_result_blocks_delta(serializer, members[2], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: + members = hydrate(_SCHEMA_CONTENT_BLOCK_DELTA).members_by_index return cls( - value=_deserialize_tool_result_blocks_delta( - deserializer, _SCHEMA_CONTENT_BLOCK_DELTA.members["toolResult"] - ) + value=_deserialize_tool_result_blocks_delta(deserializer, members[2]) ) @@ -15229,12 +14069,11 @@ class ContentBlockDeltaReasoningContent: value: ReasoningContentBlockDelta def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_CONTENT_BLOCK_DELTA, self) + serializer.write_struct(hydrate(_SCHEMA_CONTENT_BLOCK_DELTA), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_struct( - _SCHEMA_CONTENT_BLOCK_DELTA.members["reasoningContent"], self.value - ) + members = hydrate(_SCHEMA_CONTENT_BLOCK_DELTA).members_by_index + serializer.write_struct(members[3], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -15253,12 +14092,11 @@ class ContentBlockDeltaCitation: value: CitationsDelta def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_CONTENT_BLOCK_DELTA, self) + serializer.write_struct(hydrate(_SCHEMA_CONTENT_BLOCK_DELTA), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_struct( - _SCHEMA_CONTENT_BLOCK_DELTA.members["citation"], self.value - ) + members = hydrate(_SCHEMA_CONTENT_BLOCK_DELTA).members_by_index + serializer.write_struct(members[4], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -15272,12 +14110,11 @@ class ContentBlockDeltaImage: value: ImageBlockDelta def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_CONTENT_BLOCK_DELTA, self) + serializer.write_struct(hydrate(_SCHEMA_CONTENT_BLOCK_DELTA), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_struct( - _SCHEMA_CONTENT_BLOCK_DELTA.members["image"], self.value - ) + members = hydrate(_SCHEMA_CONTENT_BLOCK_DELTA).members_by_index + serializer.write_struct(members[5], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -15325,7 +14162,7 @@ class _ContentBlockDeltaDeserializer: def deserialize(self, deserializer: ShapeDeserializer) -> ContentBlockDelta: self._result = None - deserializer.read_struct(_SCHEMA_CONTENT_BLOCK_DELTA, self._consumer) + deserializer.read_struct(hydrate(_SCHEMA_CONTENT_BLOCK_DELTA), self._consumer) if self._result is None: raise SerializationError( @@ -15378,16 +14215,12 @@ class ContentBlockDeltaEvent: """The block index for a content block delta event.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_CONTENT_BLOCK_DELTA_EVENT, self) + serializer.write_struct(hydrate(_SCHEMA_CONTENT_BLOCK_DELTA_EVENT), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_struct( - _SCHEMA_CONTENT_BLOCK_DELTA_EVENT.members["delta"], self.delta - ) - serializer.write_integer( - _SCHEMA_CONTENT_BLOCK_DELTA_EVENT.members["contentBlockIndex"], - self.content_block_index, - ) + members = hydrate(_SCHEMA_CONTENT_BLOCK_DELTA_EVENT).members_by_index + serializer.write_struct(members[0], self.delta) + serializer.write_integer(members[1], self.content_block_index) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -15396,21 +14229,21 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_CONTENT_BLOCK_DELTA_EVENT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["delta"] = _ContentBlockDeltaDeserializer().deserialize(de) case 1: - kwargs["content_block_index"] = de.read_integer( - _SCHEMA_CONTENT_BLOCK_DELTA_EVENT.members["contentBlockIndex"] - ) + kwargs["content_block_index"] = de.read_integer(members[1]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_CONTENT_BLOCK_DELTA_EVENT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) if "delta" not in kwargs: kwargs["delta"] = ContentBlockDeltaUnknown(tag="") if "content_block_index" not in kwargs: @@ -15432,12 +14265,11 @@ class ImageBlockStart: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_IMAGE_BLOCK_START, self) + serializer.write_struct(hydrate(_SCHEMA_IMAGE_BLOCK_START), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_string( - _SCHEMA_IMAGE_BLOCK_START.members["format"], self.format - ) + members = hydrate(_SCHEMA_IMAGE_BLOCK_START).members_by_index + serializer.write_string(members[0], self.format) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -15446,18 +14278,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_IMAGE_BLOCK_START) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["format"] = ImageFormat( - de.read_string(_SCHEMA_IMAGE_BLOCK_START.members["format"]) - ) + kwargs["format"] = ImageFormat(de.read_string(members[0])) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_IMAGE_BLOCK_START, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) if "format" not in kwargs: kwargs["format"] = ImageFormat._corrected("") return kwargs @@ -15482,21 +14314,16 @@ class ToolResultBlockStart: """The status of the tool result block.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_TOOL_RESULT_BLOCK_START, self) + serializer.write_struct(hydrate(_SCHEMA_TOOL_RESULT_BLOCK_START), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_string( - _SCHEMA_TOOL_RESULT_BLOCK_START.members["toolUseId"], self.tool_use_id - ) + members = hydrate(_SCHEMA_TOOL_RESULT_BLOCK_START).members_by_index + serializer.write_string(members[0], self.tool_use_id) if self.type is not None: - serializer.write_string( - _SCHEMA_TOOL_RESULT_BLOCK_START.members["type"], self.type - ) + serializer.write_string(members[1], self.type) if self.status is not None: - serializer.write_string( - _SCHEMA_TOOL_RESULT_BLOCK_START.members["status"], self.status - ) + serializer.write_string(members[2], self.status) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -15505,30 +14332,24 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_TOOL_RESULT_BLOCK_START) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["tool_use_id"] = de.read_string( - _SCHEMA_TOOL_RESULT_BLOCK_START.members["toolUseId"] - ) + kwargs["tool_use_id"] = de.read_string(members[0]) case 1: - kwargs["type"] = de.read_string( - _SCHEMA_TOOL_RESULT_BLOCK_START.members["type"] - ) + kwargs["type"] = de.read_string(members[1]) case 2: - kwargs["status"] = ToolResultStatus( - de.read_string( - _SCHEMA_TOOL_RESULT_BLOCK_START.members["status"] - ) - ) + kwargs["status"] = ToolResultStatus(de.read_string(members[2])) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_TOOL_RESULT_BLOCK_START, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) if "tool_use_id" not in kwargs: kwargs["tool_use_id"] = "" return kwargs @@ -15553,17 +14374,14 @@ class ToolUseBlockStart: """The type for the tool request.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_TOOL_USE_BLOCK_START, self) + serializer.write_struct(hydrate(_SCHEMA_TOOL_USE_BLOCK_START), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_string( - _SCHEMA_TOOL_USE_BLOCK_START.members["toolUseId"], self.tool_use_id - ) - serializer.write_string(_SCHEMA_TOOL_USE_BLOCK_START.members["name"], self.name) + members = hydrate(_SCHEMA_TOOL_USE_BLOCK_START).members_by_index + serializer.write_string(members[0], self.tool_use_id) + serializer.write_string(members[1], self.name) if self.type is not None: - serializer.write_string( - _SCHEMA_TOOL_USE_BLOCK_START.members["type"], self.type - ) + serializer.write_string(members[2], self.type) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -15572,28 +14390,24 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_TOOL_USE_BLOCK_START) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["tool_use_id"] = de.read_string( - _SCHEMA_TOOL_USE_BLOCK_START.members["toolUseId"] - ) + kwargs["tool_use_id"] = de.read_string(members[0]) case 1: - kwargs["name"] = de.read_string( - _SCHEMA_TOOL_USE_BLOCK_START.members["name"] - ) + kwargs["name"] = de.read_string(members[1]) case 2: - kwargs["type"] = ToolUseType( - de.read_string(_SCHEMA_TOOL_USE_BLOCK_START.members["type"]) - ) + kwargs["type"] = ToolUseType(de.read_string(members[2])) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_TOOL_USE_BLOCK_START, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) if "tool_use_id" not in kwargs: kwargs["tool_use_id"] = "" if "name" not in kwargs: @@ -15608,12 +14422,11 @@ class ContentBlockStartToolUse: value: ToolUseBlockStart def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_CONTENT_BLOCK_START, self) + serializer.write_struct(hydrate(_SCHEMA_CONTENT_BLOCK_START), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_struct( - _SCHEMA_CONTENT_BLOCK_START.members["toolUse"], self.value - ) + members = hydrate(_SCHEMA_CONTENT_BLOCK_START).members_by_index + serializer.write_struct(members[0], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -15627,12 +14440,11 @@ class ContentBlockStartToolResult: value: ToolResultBlockStart def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_CONTENT_BLOCK_START, self) + serializer.write_struct(hydrate(_SCHEMA_CONTENT_BLOCK_START), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_struct( - _SCHEMA_CONTENT_BLOCK_START.members["toolResult"], self.value - ) + members = hydrate(_SCHEMA_CONTENT_BLOCK_START).members_by_index + serializer.write_struct(members[1], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -15646,12 +14458,11 @@ class ContentBlockStartImage: value: ImageBlockStart def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_CONTENT_BLOCK_START, self) + serializer.write_struct(hydrate(_SCHEMA_CONTENT_BLOCK_START), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_struct( - _SCHEMA_CONTENT_BLOCK_START.members["image"], self.value - ) + members = hydrate(_SCHEMA_CONTENT_BLOCK_START).members_by_index + serializer.write_struct(members[2], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -15696,7 +14507,7 @@ class _ContentBlockStartDeserializer: def deserialize(self, deserializer: ShapeDeserializer) -> ContentBlockStart: self._result = None - deserializer.read_struct(_SCHEMA_CONTENT_BLOCK_START, self._consumer) + deserializer.read_struct(hydrate(_SCHEMA_CONTENT_BLOCK_START), self._consumer) if self._result is None: raise SerializationError( @@ -15740,16 +14551,12 @@ class ContentBlockStartEvent: """The index for a content block start event.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_CONTENT_BLOCK_START_EVENT, self) + serializer.write_struct(hydrate(_SCHEMA_CONTENT_BLOCK_START_EVENT), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_struct( - _SCHEMA_CONTENT_BLOCK_START_EVENT.members["start"], self.start - ) - serializer.write_integer( - _SCHEMA_CONTENT_BLOCK_START_EVENT.members["contentBlockIndex"], - self.content_block_index, - ) + members = hydrate(_SCHEMA_CONTENT_BLOCK_START_EVENT).members_by_index + serializer.write_struct(members[0], self.start) + serializer.write_integer(members[1], self.content_block_index) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -15758,21 +14565,21 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_CONTENT_BLOCK_START_EVENT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["start"] = _ContentBlockStartDeserializer().deserialize(de) case 1: - kwargs["content_block_index"] = de.read_integer( - _SCHEMA_CONTENT_BLOCK_START_EVENT.members["contentBlockIndex"] - ) + kwargs["content_block_index"] = de.read_integer(members[1]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_CONTENT_BLOCK_START_EVENT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) if "start" not in kwargs: kwargs["start"] = ContentBlockStartUnknown(tag="") if "content_block_index" not in kwargs: @@ -15788,13 +14595,11 @@ class ContentBlockStopEvent: """The index for a content block.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_CONTENT_BLOCK_STOP_EVENT, self) + serializer.write_struct(hydrate(_SCHEMA_CONTENT_BLOCK_STOP_EVENT), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_integer( - _SCHEMA_CONTENT_BLOCK_STOP_EVENT.members["contentBlockIndex"], - self.content_block_index, - ) + members = hydrate(_SCHEMA_CONTENT_BLOCK_STOP_EVENT).members_by_index + serializer.write_integer(members[0], self.content_block_index) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -15803,18 +14608,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_CONTENT_BLOCK_STOP_EVENT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["content_block_index"] = de.read_integer( - _SCHEMA_CONTENT_BLOCK_STOP_EVENT.members["contentBlockIndex"] - ) + kwargs["content_block_index"] = de.read_integer(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_CONTENT_BLOCK_STOP_EVENT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) if "content_block_index" not in kwargs: kwargs["content_block_index"] = 0 return kwargs @@ -15828,10 +14633,11 @@ class MessageStartEvent: """The role for the message.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_MESSAGE_START_EVENT, self) + serializer.write_struct(hydrate(_SCHEMA_MESSAGE_START_EVENT), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_string(_SCHEMA_MESSAGE_START_EVENT.members["role"], self.role) + members = hydrate(_SCHEMA_MESSAGE_START_EVENT).members_by_index + serializer.write_string(members[0], self.role) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -15840,18 +14646,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_MESSAGE_START_EVENT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["role"] = ConversationRole( - de.read_string(_SCHEMA_MESSAGE_START_EVENT.members["role"]) - ) + kwargs["role"] = ConversationRole(de.read_string(members[0])) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_MESSAGE_START_EVENT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) if "role" not in kwargs: kwargs["role"] = ConversationRole._corrected("") return kwargs @@ -15868,17 +14674,13 @@ class MessageStopEvent: """The additional model response fields.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_MESSAGE_STOP_EVENT, self) + serializer.write_struct(hydrate(_SCHEMA_MESSAGE_STOP_EVENT), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_string( - _SCHEMA_MESSAGE_STOP_EVENT.members["stopReason"], self.stop_reason - ) + members = hydrate(_SCHEMA_MESSAGE_STOP_EVENT).members_by_index + serializer.write_string(members[0], self.stop_reason) if self.additional_model_response_fields is not None: - serializer.write_document( - _SCHEMA_MESSAGE_STOP_EVENT.members["additionalModelResponseFields"], - self.additional_model_response_fields, - ) + serializer.write_document(members[1], self.additional_model_response_fields) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -15887,25 +14689,23 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_MESSAGE_STOP_EVENT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["stop_reason"] = StopReason( - de.read_string(_SCHEMA_MESSAGE_STOP_EVENT.members["stopReason"]) - ) + kwargs["stop_reason"] = StopReason(de.read_string(members[0])) case 1: kwargs["additional_model_response_fields"] = de.read_document( - _SCHEMA_MESSAGE_STOP_EVENT.members[ - "additionalModelResponseFields" - ] + members[1] ) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_MESSAGE_STOP_EVENT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) if "stop_reason" not in kwargs: kwargs["stop_reason"] = StopReason._corrected("") return kwargs @@ -15919,12 +14719,11 @@ class ConverseStreamMetrics: """The latency for the streaming request, in milliseconds.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_CONVERSE_STREAM_METRICS, self) + serializer.write_struct(hydrate(_SCHEMA_CONVERSE_STREAM_METRICS), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_long( - _SCHEMA_CONVERSE_STREAM_METRICS.members["latencyMs"], self.latency_ms - ) + members = hydrate(_SCHEMA_CONVERSE_STREAM_METRICS).members_by_index + serializer.write_long(members[0], self.latency_ms) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -15933,18 +14732,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_CONVERSE_STREAM_METRICS) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["latency_ms"] = de.read_long( - _SCHEMA_CONVERSE_STREAM_METRICS.members["latencyMs"] - ) + kwargs["latency_ms"] = de.read_long(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_CONVERSE_STREAM_METRICS, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) if "latency_ms" not in kwargs: kwargs["latency_ms"] = 0 return kwargs @@ -15968,19 +14767,15 @@ class ConverseStreamTrace: """The request's prompt router.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_CONVERSE_STREAM_TRACE, self) + serializer.write_struct(hydrate(_SCHEMA_CONVERSE_STREAM_TRACE), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_CONVERSE_STREAM_TRACE).members_by_index if self.guardrail is not None: - serializer.write_struct( - _SCHEMA_CONVERSE_STREAM_TRACE.members["guardrail"], self.guardrail - ) + serializer.write_struct(members[0], self.guardrail) if self.prompt_router is not None: - serializer.write_struct( - _SCHEMA_CONVERSE_STREAM_TRACE.members["promptRouter"], - self.prompt_router, - ) + serializer.write_struct(members[1], self.prompt_router) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -15989,9 +14784,11 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_CONVERSE_STREAM_TRACE) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["guardrail"] = GuardrailTraceAssessment.deserialize(de) @@ -15999,9 +14796,9 @@ def _consumer(schema: Schema, de: ShapeDeserializer) -> None: kwargs["prompt_router"] = PromptRouterTrace.deserialize(de) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_CONVERSE_STREAM_TRACE, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -16035,31 +14832,20 @@ class ConverseStreamMetadataEvent: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_CONVERSE_STREAM_METADATA_EVENT, self) + serializer.write_struct(hydrate(_SCHEMA_CONVERSE_STREAM_METADATA_EVENT), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_struct( - _SCHEMA_CONVERSE_STREAM_METADATA_EVENT.members["usage"], self.usage - ) - serializer.write_struct( - _SCHEMA_CONVERSE_STREAM_METADATA_EVENT.members["metrics"], self.metrics - ) + members = hydrate(_SCHEMA_CONVERSE_STREAM_METADATA_EVENT).members_by_index + serializer.write_struct(members[0], self.usage) + serializer.write_struct(members[1], self.metrics) if self.trace is not None: - serializer.write_struct( - _SCHEMA_CONVERSE_STREAM_METADATA_EVENT.members["trace"], self.trace - ) + serializer.write_struct(members[2], self.trace) if self.performance_config is not None: - serializer.write_struct( - _SCHEMA_CONVERSE_STREAM_METADATA_EVENT.members["performanceConfig"], - self.performance_config, - ) + serializer.write_struct(members[3], self.performance_config) if self.service_tier is not None: - serializer.write_struct( - _SCHEMA_CONVERSE_STREAM_METADATA_EVENT.members["serviceTier"], - self.service_tier, - ) + serializer.write_struct(members[4], self.service_tier) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -16068,9 +14854,11 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_CONVERSE_STREAM_METADATA_EVENT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["usage"] = TokenUsage.deserialize(de) @@ -16089,11 +14877,9 @@ def _consumer(schema: Schema, de: ShapeDeserializer) -> None: kwargs["service_tier"] = ServiceTier.deserialize(de) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_CONVERSE_STREAM_METADATA_EVENT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) if "usage" not in kwargs: kwargs["usage"] = TokenUsage._smithy_default() if "metrics" not in kwargs: @@ -16114,25 +14900,18 @@ class ModelStreamErrorException(ServiceError): """The original message.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_MODEL_STREAM_ERROR_EXCEPTION, self) + serializer.write_struct(hydrate(_SCHEMA_MODEL_STREAM_ERROR_EXCEPTION), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_MODEL_STREAM_ERROR_EXCEPTION).members_by_index if self.message is not None: - serializer.write_string( - _SCHEMA_MODEL_STREAM_ERROR_EXCEPTION.members["message"], self.message - ) + serializer.write_string(members[0], self.message) if self.original_status_code is not None: - serializer.write_integer( - _SCHEMA_MODEL_STREAM_ERROR_EXCEPTION.members["originalStatusCode"], - self.original_status_code, - ) + serializer.write_integer(members[1], self.original_status_code) if self.original_message is not None: - serializer.write_string( - _SCHEMA_MODEL_STREAM_ERROR_EXCEPTION.members["originalMessage"], - self.original_message, - ) + serializer.write_string(members[2], self.original_message) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -16141,32 +14920,24 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_MODEL_STREAM_ERROR_EXCEPTION) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["message"] = de.read_string( - _SCHEMA_MODEL_STREAM_ERROR_EXCEPTION.members["message"] - ) + kwargs["message"] = de.read_string(members[0]) case 1: - kwargs["original_status_code"] = de.read_integer( - _SCHEMA_MODEL_STREAM_ERROR_EXCEPTION.members[ - "originalStatusCode" - ] - ) + kwargs["original_status_code"] = de.read_integer(members[1]) case 2: - kwargs["original_message"] = de.read_string( - _SCHEMA_MODEL_STREAM_ERROR_EXCEPTION.members["originalMessage"] - ) + kwargs["original_message"] = de.read_string(members[2]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_MODEL_STREAM_ERROR_EXCEPTION, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -16177,12 +14948,11 @@ class ConverseStreamOutputMessageStart: value: MessageStartEvent def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_CONVERSE_STREAM_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_CONVERSE_STREAM_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_struct( - _SCHEMA_CONVERSE_STREAM_OUTPUT.members["messageStart"], self.value - ) + members = hydrate(_SCHEMA_CONVERSE_STREAM_OUTPUT).members_by_index + serializer.write_struct(members[0], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -16196,12 +14966,11 @@ class ConverseStreamOutputContentBlockStart: value: ContentBlockStartEvent def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_CONVERSE_STREAM_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_CONVERSE_STREAM_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_struct( - _SCHEMA_CONVERSE_STREAM_OUTPUT.members["contentBlockStart"], self.value - ) + members = hydrate(_SCHEMA_CONVERSE_STREAM_OUTPUT).members_by_index + serializer.write_struct(members[1], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -16215,12 +14984,11 @@ class ConverseStreamOutputContentBlockDelta: value: ContentBlockDeltaEvent def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_CONVERSE_STREAM_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_CONVERSE_STREAM_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_struct( - _SCHEMA_CONVERSE_STREAM_OUTPUT.members["contentBlockDelta"], self.value - ) + members = hydrate(_SCHEMA_CONVERSE_STREAM_OUTPUT).members_by_index + serializer.write_struct(members[2], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -16234,12 +15002,11 @@ class ConverseStreamOutputContentBlockStop: value: ContentBlockStopEvent def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_CONVERSE_STREAM_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_CONVERSE_STREAM_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_struct( - _SCHEMA_CONVERSE_STREAM_OUTPUT.members["contentBlockStop"], self.value - ) + members = hydrate(_SCHEMA_CONVERSE_STREAM_OUTPUT).members_by_index + serializer.write_struct(members[3], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -16253,12 +15020,11 @@ class ConverseStreamOutputMessageStop: value: MessageStopEvent def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_CONVERSE_STREAM_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_CONVERSE_STREAM_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_struct( - _SCHEMA_CONVERSE_STREAM_OUTPUT.members["messageStop"], self.value - ) + members = hydrate(_SCHEMA_CONVERSE_STREAM_OUTPUT).members_by_index + serializer.write_struct(members[4], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -16272,12 +15038,11 @@ class ConverseStreamOutputMetadata: value: ConverseStreamMetadataEvent def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_CONVERSE_STREAM_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_CONVERSE_STREAM_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_struct( - _SCHEMA_CONVERSE_STREAM_OUTPUT.members["metadata"], self.value - ) + members = hydrate(_SCHEMA_CONVERSE_STREAM_OUTPUT).members_by_index + serializer.write_struct(members[5], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -16291,13 +15056,11 @@ class ConverseStreamOutputInternalServerException: value: InternalServerException def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_CONVERSE_STREAM_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_CONVERSE_STREAM_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_struct( - _SCHEMA_CONVERSE_STREAM_OUTPUT.members["internalServerException"], - self.value, - ) + members = hydrate(_SCHEMA_CONVERSE_STREAM_OUTPUT).members_by_index + serializer.write_struct(members[6], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -16311,13 +15074,11 @@ class ConverseStreamOutputModelStreamErrorException: value: ModelStreamErrorException def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_CONVERSE_STREAM_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_CONVERSE_STREAM_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_struct( - _SCHEMA_CONVERSE_STREAM_OUTPUT.members["modelStreamErrorException"], - self.value, - ) + members = hydrate(_SCHEMA_CONVERSE_STREAM_OUTPUT).members_by_index + serializer.write_struct(members[7], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -16336,12 +15097,11 @@ class ConverseStreamOutputValidationException: value: ValidationException def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_CONVERSE_STREAM_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_CONVERSE_STREAM_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_struct( - _SCHEMA_CONVERSE_STREAM_OUTPUT.members["validationException"], self.value - ) + members = hydrate(_SCHEMA_CONVERSE_STREAM_OUTPUT).members_by_index + serializer.write_struct(members[8], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -16360,12 +15120,11 @@ class ConverseStreamOutputThrottlingException: value: ThrottlingException def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_CONVERSE_STREAM_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_CONVERSE_STREAM_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_struct( - _SCHEMA_CONVERSE_STREAM_OUTPUT.members["throttlingException"], self.value - ) + members = hydrate(_SCHEMA_CONVERSE_STREAM_OUTPUT).members_by_index + serializer.write_struct(members[9], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -16384,13 +15143,11 @@ class ConverseStreamOutputServiceUnavailableException: value: ServiceUnavailableException def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_CONVERSE_STREAM_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_CONVERSE_STREAM_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_struct( - _SCHEMA_CONVERSE_STREAM_OUTPUT.members["serviceUnavailableException"], - self.value, - ) + members = hydrate(_SCHEMA_CONVERSE_STREAM_OUTPUT).members_by_index + serializer.write_struct(members[10], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -16443,7 +15200,9 @@ class _ConverseStreamOutputDeserializer: def deserialize(self, deserializer: ShapeDeserializer) -> ConverseStreamOutput: self._result = None - deserializer.read_struct(_SCHEMA_CONVERSE_STREAM_OUTPUT, self._consumer) + deserializer.read_struct( + hydrate(_SCHEMA_CONVERSE_STREAM_OUTPUT), self._consumer + ) if self._result is None: raise SerializationError( @@ -16525,7 +15284,7 @@ class ConverseStreamOperationOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_CONVERSE_STREAM_OPERATION_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_CONVERSE_STREAM_OPERATION_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -16537,24 +15296,21 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_CONVERSE_STREAM_OPERATION_OUTPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_CONVERSE_STREAM_OPERATION_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs CONVERSE_STREAM = APIOperation( input=ConverseStreamInput, output=ConverseStreamOperationOutput, - schema=_SCHEMA_CONVERSE_STREAM, - input_schema=_SCHEMA_CONVERSE_STREAM_INPUT, - output_schema=_SCHEMA_CONVERSE_STREAM_OPERATION_OUTPUT, + static_schema=_SCHEMA_CONVERSE_STREAM, error_registry=TypeRegistry( { ShapeID( @@ -16590,17 +15346,6 @@ def _consumer(schema: Schema, de: ShapeDeserializer) -> None: ShapeID("aws.auth#sigv4"), ShapeID("smithy.api#httpBearerAuth"), ], - error_schemas=[ - _SCHEMA_ACCESS_DENIED_EXCEPTION, - _SCHEMA_INTERNAL_SERVER_EXCEPTION, - _SCHEMA_MODEL_ERROR_EXCEPTION, - _SCHEMA_MODEL_NOT_READY_EXCEPTION, - _SCHEMA_MODEL_TIMEOUT_EXCEPTION, - _SCHEMA_RESOURCE_NOT_FOUND_EXCEPTION, - _SCHEMA_SERVICE_UNAVAILABLE_EXCEPTION, - _SCHEMA_THROTTLING_EXCEPTION, - _SCHEMA_VALIDATION_EXCEPTION, - ], ) @@ -16714,60 +15459,39 @@ class InvokeModelInput: """Key-value pairs that you can use to filter invocation logs.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_INVOKE_MODEL_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_INVOKE_MODEL_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_INVOKE_MODEL_INPUT).members_by_index if self.body is not None: - serializer.write_blob(_SCHEMA_INVOKE_MODEL_INPUT.members["body"], self.body) + serializer.write_blob(members[0], self.body) if self.content_type is not None: - serializer.write_string( - _SCHEMA_INVOKE_MODEL_INPUT.members["contentType"], self.content_type - ) + serializer.write_string(members[1], self.content_type) if self.accept is not None: - serializer.write_string( - _SCHEMA_INVOKE_MODEL_INPUT.members["accept"], self.accept - ) + serializer.write_string(members[2], self.accept) if self.model_id is not None: - serializer.write_string( - _SCHEMA_INVOKE_MODEL_INPUT.members["modelId"], self.model_id - ) + serializer.write_string(members[3], self.model_id) if self.trace is not None: - serializer.write_string( - _SCHEMA_INVOKE_MODEL_INPUT.members["trace"], self.trace - ) + serializer.write_string(members[4], self.trace) if self.guardrail_identifier is not None: - serializer.write_string( - _SCHEMA_INVOKE_MODEL_INPUT.members["guardrailIdentifier"], - self.guardrail_identifier, - ) + serializer.write_string(members[5], self.guardrail_identifier) if self.guardrail_version is not None: - serializer.write_string( - _SCHEMA_INVOKE_MODEL_INPUT.members["guardrailVersion"], - self.guardrail_version, - ) + serializer.write_string(members[6], self.guardrail_version) if self.performance_config_latency is not None: - serializer.write_string( - _SCHEMA_INVOKE_MODEL_INPUT.members["performanceConfigLatency"], - self.performance_config_latency, - ) + serializer.write_string(members[7], self.performance_config_latency) if self.service_tier is not None: - serializer.write_string( - _SCHEMA_INVOKE_MODEL_INPUT.members["serviceTier"], self.service_tier - ) + serializer.write_string(members[8], self.service_tier) if self.request_metadata is not None: - serializer.write_string( - _SCHEMA_INVOKE_MODEL_INPUT.members["requestMetadata"], - self.request_metadata, - ) + serializer.write_string(members[9], self.request_metadata) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -16776,69 +15500,47 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_INVOKE_MODEL_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["body"] = de.read_blob( - _SCHEMA_INVOKE_MODEL_INPUT.members["body"] - ) + kwargs["body"] = de.read_blob(members[0]) case 1: - kwargs["content_type"] = de.read_string( - _SCHEMA_INVOKE_MODEL_INPUT.members["contentType"] - ) + kwargs["content_type"] = de.read_string(members[1]) case 2: - kwargs["accept"] = de.read_string( - _SCHEMA_INVOKE_MODEL_INPUT.members["accept"] - ) + kwargs["accept"] = de.read_string(members[2]) case 3: - kwargs["model_id"] = de.read_string( - _SCHEMA_INVOKE_MODEL_INPUT.members["modelId"] - ) + kwargs["model_id"] = de.read_string(members[3]) case 4: - kwargs["trace"] = Trace( - de.read_string(_SCHEMA_INVOKE_MODEL_INPUT.members["trace"]) - ) + kwargs["trace"] = Trace(de.read_string(members[4])) case 5: - kwargs["guardrail_identifier"] = de.read_string( - _SCHEMA_INVOKE_MODEL_INPUT.members["guardrailIdentifier"] - ) + kwargs["guardrail_identifier"] = de.read_string(members[5]) case 6: - kwargs["guardrail_version"] = de.read_string( - _SCHEMA_INVOKE_MODEL_INPUT.members["guardrailVersion"] - ) + kwargs["guardrail_version"] = de.read_string(members[6]) case 7: kwargs["performance_config_latency"] = PerformanceConfigLatency( - de.read_string( - _SCHEMA_INVOKE_MODEL_INPUT.members[ - "performanceConfigLatency" - ] - ) + de.read_string(members[7]) ) case 8: - kwargs["service_tier"] = ServiceTierType( - de.read_string( - _SCHEMA_INVOKE_MODEL_INPUT.members["serviceTier"] - ) - ) + kwargs["service_tier"] = ServiceTierType(de.read_string(members[8])) case 9: - kwargs["request_metadata"] = de.read_string( - _SCHEMA_INVOKE_MODEL_INPUT.members["requestMetadata"] - ) + kwargs["request_metadata"] = de.read_string(members[9]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_INVOKE_MODEL_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -16874,23 +15576,17 @@ class InvokeModelOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_INVOKE_MODEL_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_INVOKE_MODEL_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_blob(_SCHEMA_INVOKE_MODEL_OUTPUT.members["body"], self.body) - serializer.write_string( - _SCHEMA_INVOKE_MODEL_OUTPUT.members["contentType"], self.content_type - ) + members = hydrate(_SCHEMA_INVOKE_MODEL_OUTPUT).members_by_index + serializer.write_blob(members[0], self.body) + serializer.write_string(members[1], self.content_type) if self.performance_config_latency is not None: - serializer.write_string( - _SCHEMA_INVOKE_MODEL_OUTPUT.members["performanceConfigLatency"], - self.performance_config_latency, - ) + serializer.write_string(members[2], self.performance_config_latency) if self.service_tier is not None: - serializer.write_string( - _SCHEMA_INVOKE_MODEL_OUTPUT.members["serviceTier"], self.service_tier - ) + serializer.write_string(members[3], self.service_tier) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -16899,39 +15595,29 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_INVOKE_MODEL_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["body"] = de.read_blob( - _SCHEMA_INVOKE_MODEL_OUTPUT.members["body"] - ) + kwargs["body"] = de.read_blob(members[0]) case 1: - kwargs["content_type"] = de.read_string( - _SCHEMA_INVOKE_MODEL_OUTPUT.members["contentType"] - ) + kwargs["content_type"] = de.read_string(members[1]) case 2: kwargs["performance_config_latency"] = PerformanceConfigLatency( - de.read_string( - _SCHEMA_INVOKE_MODEL_OUTPUT.members[ - "performanceConfigLatency" - ] - ) + de.read_string(members[2]) ) case 3: - kwargs["service_tier"] = ServiceTierType( - de.read_string( - _SCHEMA_INVOKE_MODEL_OUTPUT.members["serviceTier"] - ) - ) + kwargs["service_tier"] = ServiceTierType(de.read_string(members[3])) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_INVOKE_MODEL_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) if "body" not in kwargs: kwargs["body"] = b"" if "content_type" not in kwargs: @@ -16942,9 +15628,7 @@ def _consumer(schema: Schema, de: ShapeDeserializer) -> None: INVOKE_MODEL = APIOperation( input=InvokeModelInput, output=InvokeModelOutput, - schema=_SCHEMA_INVOKE_MODEL, - input_schema=_SCHEMA_INVOKE_MODEL_INPUT, - output_schema=_SCHEMA_INVOKE_MODEL_OUTPUT, + static_schema=_SCHEMA_INVOKE_MODEL, error_registry=TypeRegistry( { ShapeID( @@ -16983,18 +15667,6 @@ def _consumer(schema: Schema, de: ShapeDeserializer) -> None: ShapeID("aws.auth#sigv4"), ShapeID("smithy.api#httpBearerAuth"), ], - error_schemas=[ - _SCHEMA_ACCESS_DENIED_EXCEPTION, - _SCHEMA_INTERNAL_SERVER_EXCEPTION, - _SCHEMA_MODEL_ERROR_EXCEPTION, - _SCHEMA_MODEL_NOT_READY_EXCEPTION, - _SCHEMA_MODEL_TIMEOUT_EXCEPTION, - _SCHEMA_RESOURCE_NOT_FOUND_EXCEPTION, - _SCHEMA_SERVICE_QUOTA_EXCEEDED_EXCEPTION, - _SCHEMA_SERVICE_UNAVAILABLE_EXCEPTION, - _SCHEMA_THROTTLING_EXCEPTION, - _SCHEMA_VALIDATION_EXCEPTION, - ], ) @@ -17009,13 +15681,12 @@ class BidirectionalInputPayloadPart: """The audio content for the bidirectional input.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_BIDIRECTIONAL_INPUT_PAYLOAD_PART, self) + serializer.write_struct(hydrate(_SCHEMA_BIDIRECTIONAL_INPUT_PAYLOAD_PART), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_BIDIRECTIONAL_INPUT_PAYLOAD_PART).members_by_index if self.bytes_ is not None: - serializer.write_blob( - _SCHEMA_BIDIRECTIONAL_INPUT_PAYLOAD_PART.members["bytes"], self.bytes_ - ) + serializer.write_blob(members[0], self.bytes_) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -17024,20 +15695,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_BIDIRECTIONAL_INPUT_PAYLOAD_PART) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["bytes_"] = de.read_blob( - _SCHEMA_BIDIRECTIONAL_INPUT_PAYLOAD_PART.members["bytes"] - ) + kwargs["bytes_"] = de.read_blob(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_BIDIRECTIONAL_INPUT_PAYLOAD_PART, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -17049,14 +15718,14 @@ class InvokeModelWithBidirectionalStreamInputChunk: def serialize(self, serializer: ShapeSerializer): serializer.write_struct( - _SCHEMA_INVOKE_MODEL_WITH_BIDIRECTIONAL_STREAM_INPUT, self + hydrate(_SCHEMA_INVOKE_MODEL_WITH_BIDIRECTIONAL_STREAM_INPUT), self ) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_struct( - _SCHEMA_INVOKE_MODEL_WITH_BIDIRECTIONAL_STREAM_INPUT.members["chunk"], - self.value, - ) + members = hydrate( + _SCHEMA_INVOKE_MODEL_WITH_BIDIRECTIONAL_STREAM_INPUT + ).members_by_index + serializer.write_struct(members[0], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -17105,7 +15774,8 @@ def deserialize( ) -> InvokeModelWithBidirectionalStreamInput: self._result = None deserializer.read_struct( - _SCHEMA_INVOKE_MODEL_WITH_BIDIRECTIONAL_STREAM_INPUT, self._consumer + hydrate(_SCHEMA_INVOKE_MODEL_WITH_BIDIRECTIONAL_STREAM_INPUT), + self._consumer, ) if self._result is None: @@ -17152,17 +15822,16 @@ class InvokeModelWithBidirectionalStreamOperationInput: def serialize(self, serializer: ShapeSerializer): serializer.write_struct( - _SCHEMA_INVOKE_MODEL_WITH_BIDIRECTIONAL_STREAM_OPERATION_INPUT, self + hydrate(_SCHEMA_INVOKE_MODEL_WITH_BIDIRECTIONAL_STREAM_OPERATION_INPUT), + self, ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate( + _SCHEMA_INVOKE_MODEL_WITH_BIDIRECTIONAL_STREAM_OPERATION_INPUT + ).members_by_index if self.model_id is not None: - serializer.write_string( - _SCHEMA_INVOKE_MODEL_WITH_BIDIRECTIONAL_STREAM_OPERATION_INPUT.members[ - "modelId" - ], - self.model_id, - ) + serializer.write_string(members[0], self.model_id) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -17171,23 +15840,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_INVOKE_MODEL_WITH_BIDIRECTIONAL_STREAM_OPERATION_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["model_id"] = de.read_string( - _SCHEMA_INVOKE_MODEL_WITH_BIDIRECTIONAL_STREAM_OPERATION_INPUT.members[ - "modelId" - ] - ) + kwargs["model_id"] = de.read_string(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_INVOKE_MODEL_WITH_BIDIRECTIONAL_STREAM_OPERATION_INPUT, - consumer=_consumer, - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -17202,13 +15866,14 @@ class BidirectionalOutputPayloadPart: """The speech output of the bidirectional stream.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_BIDIRECTIONAL_OUTPUT_PAYLOAD_PART, self) + serializer.write_struct( + hydrate(_SCHEMA_BIDIRECTIONAL_OUTPUT_PAYLOAD_PART), self + ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_BIDIRECTIONAL_OUTPUT_PAYLOAD_PART).members_by_index if self.bytes_ is not None: - serializer.write_blob( - _SCHEMA_BIDIRECTIONAL_OUTPUT_PAYLOAD_PART.members["bytes"], self.bytes_ - ) + serializer.write_blob(members[0], self.bytes_) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -17217,20 +15882,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_BIDIRECTIONAL_OUTPUT_PAYLOAD_PART) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["bytes_"] = de.read_blob( - _SCHEMA_BIDIRECTIONAL_OUTPUT_PAYLOAD_PART.members["bytes"] - ) + kwargs["bytes_"] = de.read_blob(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_BIDIRECTIONAL_OUTPUT_PAYLOAD_PART, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -17242,14 +15905,14 @@ class InvokeModelWithBidirectionalStreamOutputChunk: def serialize(self, serializer: ShapeSerializer): serializer.write_struct( - _SCHEMA_INVOKE_MODEL_WITH_BIDIRECTIONAL_STREAM_OUTPUT, self + hydrate(_SCHEMA_INVOKE_MODEL_WITH_BIDIRECTIONAL_STREAM_OUTPUT), self ) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_struct( - _SCHEMA_INVOKE_MODEL_WITH_BIDIRECTIONAL_STREAM_OUTPUT.members["chunk"], - self.value, - ) + members = hydrate( + _SCHEMA_INVOKE_MODEL_WITH_BIDIRECTIONAL_STREAM_OUTPUT + ).members_by_index + serializer.write_struct(members[0], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -17264,16 +15927,14 @@ class InvokeModelWithBidirectionalStreamOutputInternalServerException: def serialize(self, serializer: ShapeSerializer): serializer.write_struct( - _SCHEMA_INVOKE_MODEL_WITH_BIDIRECTIONAL_STREAM_OUTPUT, self + hydrate(_SCHEMA_INVOKE_MODEL_WITH_BIDIRECTIONAL_STREAM_OUTPUT), self ) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_struct( - _SCHEMA_INVOKE_MODEL_WITH_BIDIRECTIONAL_STREAM_OUTPUT.members[ - "internalServerException" - ], - self.value, - ) + members = hydrate( + _SCHEMA_INVOKE_MODEL_WITH_BIDIRECTIONAL_STREAM_OUTPUT + ).members_by_index + serializer.write_struct(members[1], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -17288,16 +15949,14 @@ class InvokeModelWithBidirectionalStreamOutputModelStreamErrorException: def serialize(self, serializer: ShapeSerializer): serializer.write_struct( - _SCHEMA_INVOKE_MODEL_WITH_BIDIRECTIONAL_STREAM_OUTPUT, self + hydrate(_SCHEMA_INVOKE_MODEL_WITH_BIDIRECTIONAL_STREAM_OUTPUT), self ) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_struct( - _SCHEMA_INVOKE_MODEL_WITH_BIDIRECTIONAL_STREAM_OUTPUT.members[ - "modelStreamErrorException" - ], - self.value, - ) + members = hydrate( + _SCHEMA_INVOKE_MODEL_WITH_BIDIRECTIONAL_STREAM_OUTPUT + ).members_by_index + serializer.write_struct(members[2], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -17315,16 +15974,14 @@ class InvokeModelWithBidirectionalStreamOutputValidationException: def serialize(self, serializer: ShapeSerializer): serializer.write_struct( - _SCHEMA_INVOKE_MODEL_WITH_BIDIRECTIONAL_STREAM_OUTPUT, self + hydrate(_SCHEMA_INVOKE_MODEL_WITH_BIDIRECTIONAL_STREAM_OUTPUT), self ) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_struct( - _SCHEMA_INVOKE_MODEL_WITH_BIDIRECTIONAL_STREAM_OUTPUT.members[ - "validationException" - ], - self.value, - ) + members = hydrate( + _SCHEMA_INVOKE_MODEL_WITH_BIDIRECTIONAL_STREAM_OUTPUT + ).members_by_index + serializer.write_struct(members[3], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -17339,16 +15996,14 @@ class InvokeModelWithBidirectionalStreamOutputThrottlingException: def serialize(self, serializer: ShapeSerializer): serializer.write_struct( - _SCHEMA_INVOKE_MODEL_WITH_BIDIRECTIONAL_STREAM_OUTPUT, self + hydrate(_SCHEMA_INVOKE_MODEL_WITH_BIDIRECTIONAL_STREAM_OUTPUT), self ) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_struct( - _SCHEMA_INVOKE_MODEL_WITH_BIDIRECTIONAL_STREAM_OUTPUT.members[ - "throttlingException" - ], - self.value, - ) + members = hydrate( + _SCHEMA_INVOKE_MODEL_WITH_BIDIRECTIONAL_STREAM_OUTPUT + ).members_by_index + serializer.write_struct(members[4], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -17366,16 +16021,14 @@ class InvokeModelWithBidirectionalStreamOutputModelTimeoutException: def serialize(self, serializer: ShapeSerializer): serializer.write_struct( - _SCHEMA_INVOKE_MODEL_WITH_BIDIRECTIONAL_STREAM_OUTPUT, self + hydrate(_SCHEMA_INVOKE_MODEL_WITH_BIDIRECTIONAL_STREAM_OUTPUT), self ) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_struct( - _SCHEMA_INVOKE_MODEL_WITH_BIDIRECTIONAL_STREAM_OUTPUT.members[ - "modelTimeoutException" - ], - self.value, - ) + members = hydrate( + _SCHEMA_INVOKE_MODEL_WITH_BIDIRECTIONAL_STREAM_OUTPUT + ).members_by_index + serializer.write_struct(members[5], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -17390,16 +16043,14 @@ class InvokeModelWithBidirectionalStreamOutputServiceUnavailableException: def serialize(self, serializer: ShapeSerializer): serializer.write_struct( - _SCHEMA_INVOKE_MODEL_WITH_BIDIRECTIONAL_STREAM_OUTPUT, self + hydrate(_SCHEMA_INVOKE_MODEL_WITH_BIDIRECTIONAL_STREAM_OUTPUT), self ) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_struct( - _SCHEMA_INVOKE_MODEL_WITH_BIDIRECTIONAL_STREAM_OUTPUT.members[ - "serviceUnavailableException" - ], - self.value, - ) + members = hydrate( + _SCHEMA_INVOKE_MODEL_WITH_BIDIRECTIONAL_STREAM_OUTPUT + ).members_by_index + serializer.write_struct(members[6], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -17451,7 +16102,8 @@ def deserialize( ) -> InvokeModelWithBidirectionalStreamOutput: self._result = None deserializer.read_struct( - _SCHEMA_INVOKE_MODEL_WITH_BIDIRECTIONAL_STREAM_OUTPUT, self._consumer + hydrate(_SCHEMA_INVOKE_MODEL_WITH_BIDIRECTIONAL_STREAM_OUTPUT), + self._consumer, ) if self._result is None: @@ -17544,7 +16196,8 @@ class InvokeModelWithBidirectionalStreamOperationOutput: def serialize(self, serializer: ShapeSerializer): serializer.write_struct( - _SCHEMA_INVOKE_MODEL_WITH_BIDIRECTIONAL_STREAM_OPERATION_OUTPUT, self + hydrate(_SCHEMA_INVOKE_MODEL_WITH_BIDIRECTIONAL_STREAM_OPERATION_OUTPUT), + self, ) def serialize_members(self, serializer: ShapeSerializer): @@ -17557,25 +16210,23 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate( + _SCHEMA_INVOKE_MODEL_WITH_BIDIRECTIONAL_STREAM_OPERATION_OUTPUT + ) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_INVOKE_MODEL_WITH_BIDIRECTIONAL_STREAM_OPERATION_OUTPUT, - consumer=_consumer, - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs INVOKE_MODEL_WITH_BIDIRECTIONAL_STREAM = APIOperation( input=InvokeModelWithBidirectionalStreamOperationInput, output=InvokeModelWithBidirectionalStreamOperationOutput, - schema=_SCHEMA_INVOKE_MODEL_WITH_BIDIRECTIONAL_STREAM, - input_schema=_SCHEMA_INVOKE_MODEL_WITH_BIDIRECTIONAL_STREAM_OPERATION_INPUT, - output_schema=_SCHEMA_INVOKE_MODEL_WITH_BIDIRECTIONAL_STREAM_OPERATION_OUTPUT, + static_schema=_SCHEMA_INVOKE_MODEL_WITH_BIDIRECTIONAL_STREAM, error_registry=TypeRegistry( { ShapeID( @@ -17617,19 +16268,6 @@ def _consumer(schema: Schema, de: ShapeDeserializer) -> None: ShapeID("aws.auth#sigv4"), ShapeID("smithy.api#httpBearerAuth"), ], - error_schemas=[ - _SCHEMA_ACCESS_DENIED_EXCEPTION, - _SCHEMA_INTERNAL_SERVER_EXCEPTION, - _SCHEMA_MODEL_ERROR_EXCEPTION, - _SCHEMA_MODEL_NOT_READY_EXCEPTION, - _SCHEMA_MODEL_STREAM_ERROR_EXCEPTION, - _SCHEMA_MODEL_TIMEOUT_EXCEPTION, - _SCHEMA_RESOURCE_NOT_FOUND_EXCEPTION, - _SCHEMA_SERVICE_QUOTA_EXCEEDED_EXCEPTION, - _SCHEMA_SERVICE_UNAVAILABLE_EXCEPTION, - _SCHEMA_THROTTLING_EXCEPTION, - _SCHEMA_VALIDATION_EXCEPTION, - ], ) @@ -17737,76 +16375,43 @@ class InvokeModelWithResponseStreamInput: """Key-value pairs that you can use to filter invocation logs.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_INVOKE_MODEL_WITH_RESPONSE_STREAM_INPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_INVOKE_MODEL_WITH_RESPONSE_STREAM_INPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate( + _SCHEMA_INVOKE_MODEL_WITH_RESPONSE_STREAM_INPUT + ).members_by_index if self.body is not None: - serializer.write_blob( - _SCHEMA_INVOKE_MODEL_WITH_RESPONSE_STREAM_INPUT.members["body"], - self.body, - ) + serializer.write_blob(members[0], self.body) if self.content_type is not None: - serializer.write_string( - _SCHEMA_INVOKE_MODEL_WITH_RESPONSE_STREAM_INPUT.members["contentType"], - self.content_type, - ) + serializer.write_string(members[1], self.content_type) if self.accept is not None: - serializer.write_string( - _SCHEMA_INVOKE_MODEL_WITH_RESPONSE_STREAM_INPUT.members["accept"], - self.accept, - ) + serializer.write_string(members[2], self.accept) if self.model_id is not None: - serializer.write_string( - _SCHEMA_INVOKE_MODEL_WITH_RESPONSE_STREAM_INPUT.members["modelId"], - self.model_id, - ) + serializer.write_string(members[3], self.model_id) if self.trace is not None: - serializer.write_string( - _SCHEMA_INVOKE_MODEL_WITH_RESPONSE_STREAM_INPUT.members["trace"], - self.trace, - ) + serializer.write_string(members[4], self.trace) if self.guardrail_identifier is not None: - serializer.write_string( - _SCHEMA_INVOKE_MODEL_WITH_RESPONSE_STREAM_INPUT.members[ - "guardrailIdentifier" - ], - self.guardrail_identifier, - ) + serializer.write_string(members[5], self.guardrail_identifier) if self.guardrail_version is not None: - serializer.write_string( - _SCHEMA_INVOKE_MODEL_WITH_RESPONSE_STREAM_INPUT.members[ - "guardrailVersion" - ], - self.guardrail_version, - ) + serializer.write_string(members[6], self.guardrail_version) if self.performance_config_latency is not None: - serializer.write_string( - _SCHEMA_INVOKE_MODEL_WITH_RESPONSE_STREAM_INPUT.members[ - "performanceConfigLatency" - ], - self.performance_config_latency, - ) + serializer.write_string(members[7], self.performance_config_latency) if self.service_tier is not None: - serializer.write_string( - _SCHEMA_INVOKE_MODEL_WITH_RESPONSE_STREAM_INPUT.members["serviceTier"], - self.service_tier, - ) + serializer.write_string(members[8], self.service_tier) if self.request_metadata is not None: - serializer.write_string( - _SCHEMA_INVOKE_MODEL_WITH_RESPONSE_STREAM_INPUT.members[ - "requestMetadata" - ], - self.request_metadata, - ) + serializer.write_string(members[9], self.request_metadata) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -17815,89 +16420,47 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_INVOKE_MODEL_WITH_RESPONSE_STREAM_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["body"] = de.read_blob( - _SCHEMA_INVOKE_MODEL_WITH_RESPONSE_STREAM_INPUT.members["body"] - ) + kwargs["body"] = de.read_blob(members[0]) case 1: - kwargs["content_type"] = de.read_string( - _SCHEMA_INVOKE_MODEL_WITH_RESPONSE_STREAM_INPUT.members[ - "contentType" - ] - ) + kwargs["content_type"] = de.read_string(members[1]) case 2: - kwargs["accept"] = de.read_string( - _SCHEMA_INVOKE_MODEL_WITH_RESPONSE_STREAM_INPUT.members[ - "accept" - ] - ) + kwargs["accept"] = de.read_string(members[2]) case 3: - kwargs["model_id"] = de.read_string( - _SCHEMA_INVOKE_MODEL_WITH_RESPONSE_STREAM_INPUT.members[ - "modelId" - ] - ) + kwargs["model_id"] = de.read_string(members[3]) case 4: - kwargs["trace"] = Trace( - de.read_string( - _SCHEMA_INVOKE_MODEL_WITH_RESPONSE_STREAM_INPUT.members[ - "trace" - ] - ) - ) + kwargs["trace"] = Trace(de.read_string(members[4])) case 5: - kwargs["guardrail_identifier"] = de.read_string( - _SCHEMA_INVOKE_MODEL_WITH_RESPONSE_STREAM_INPUT.members[ - "guardrailIdentifier" - ] - ) + kwargs["guardrail_identifier"] = de.read_string(members[5]) case 6: - kwargs["guardrail_version"] = de.read_string( - _SCHEMA_INVOKE_MODEL_WITH_RESPONSE_STREAM_INPUT.members[ - "guardrailVersion" - ] - ) + kwargs["guardrail_version"] = de.read_string(members[6]) case 7: kwargs["performance_config_latency"] = PerformanceConfigLatency( - de.read_string( - _SCHEMA_INVOKE_MODEL_WITH_RESPONSE_STREAM_INPUT.members[ - "performanceConfigLatency" - ] - ) + de.read_string(members[7]) ) case 8: - kwargs["service_tier"] = ServiceTierType( - de.read_string( - _SCHEMA_INVOKE_MODEL_WITH_RESPONSE_STREAM_INPUT.members[ - "serviceTier" - ] - ) - ) + kwargs["service_tier"] = ServiceTierType(de.read_string(members[8])) case 9: - kwargs["request_metadata"] = de.read_string( - _SCHEMA_INVOKE_MODEL_WITH_RESPONSE_STREAM_INPUT.members[ - "requestMetadata" - ] - ) + kwargs["request_metadata"] = de.read_string(members[9]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_INVOKE_MODEL_WITH_RESPONSE_STREAM_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -17909,11 +16472,12 @@ class PayloadPart: """Base64-encoded bytes of payload data.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_PAYLOAD_PART, self) + serializer.write_struct(hydrate(_SCHEMA_PAYLOAD_PART), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_PAYLOAD_PART).members_by_index if self.bytes_ is not None: - serializer.write_blob(_SCHEMA_PAYLOAD_PART.members["bytes"], self.bytes_) + serializer.write_blob(members[0], self.bytes_) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -17922,18 +16486,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_PAYLOAD_PART) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["bytes_"] = de.read_blob( - _SCHEMA_PAYLOAD_PART.members["bytes"] - ) + kwargs["bytes_"] = de.read_blob(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_PAYLOAD_PART, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -17944,10 +16508,11 @@ class ResponseStreamChunk: value: PayloadPart def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_RESPONSE_STREAM, self) + serializer.write_struct(hydrate(_SCHEMA_RESPONSE_STREAM), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_RESPONSE_STREAM.members["chunk"], self.value) + members = hydrate(_SCHEMA_RESPONSE_STREAM).members_by_index + serializer.write_struct(members[0], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -17961,12 +16526,11 @@ class ResponseStreamInternalServerException: value: InternalServerException def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_RESPONSE_STREAM, self) + serializer.write_struct(hydrate(_SCHEMA_RESPONSE_STREAM), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_struct( - _SCHEMA_RESPONSE_STREAM.members["internalServerException"], self.value - ) + members = hydrate(_SCHEMA_RESPONSE_STREAM).members_by_index + serializer.write_struct(members[1], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -17980,12 +16544,11 @@ class ResponseStreamModelStreamErrorException: value: ModelStreamErrorException def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_RESPONSE_STREAM, self) + serializer.write_struct(hydrate(_SCHEMA_RESPONSE_STREAM), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_struct( - _SCHEMA_RESPONSE_STREAM.members["modelStreamErrorException"], self.value - ) + members = hydrate(_SCHEMA_RESPONSE_STREAM).members_by_index + serializer.write_struct(members[2], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -18002,12 +16565,11 @@ class ResponseStreamValidationException: value: ValidationException def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_RESPONSE_STREAM, self) + serializer.write_struct(hydrate(_SCHEMA_RESPONSE_STREAM), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_struct( - _SCHEMA_RESPONSE_STREAM.members["validationException"], self.value - ) + members = hydrate(_SCHEMA_RESPONSE_STREAM).members_by_index + serializer.write_struct(members[3], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -18027,12 +16589,11 @@ class ResponseStreamThrottlingException: value: ThrottlingException def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_RESPONSE_STREAM, self) + serializer.write_struct(hydrate(_SCHEMA_RESPONSE_STREAM), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_struct( - _SCHEMA_RESPONSE_STREAM.members["throttlingException"], self.value - ) + members = hydrate(_SCHEMA_RESPONSE_STREAM).members_by_index + serializer.write_struct(members[4], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -18049,12 +16610,11 @@ class ResponseStreamModelTimeoutException: value: ModelTimeoutException def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_RESPONSE_STREAM, self) + serializer.write_struct(hydrate(_SCHEMA_RESPONSE_STREAM), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_struct( - _SCHEMA_RESPONSE_STREAM.members["modelTimeoutException"], self.value - ) + members = hydrate(_SCHEMA_RESPONSE_STREAM).members_by_index + serializer.write_struct(members[5], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -18068,12 +16628,11 @@ class ResponseStreamServiceUnavailableException: value: ServiceUnavailableException def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_RESPONSE_STREAM, self) + serializer.write_struct(hydrate(_SCHEMA_RESPONSE_STREAM), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_struct( - _SCHEMA_RESPONSE_STREAM.members["serviceUnavailableException"], self.value - ) + members = hydrate(_SCHEMA_RESPONSE_STREAM).members_by_index + serializer.write_struct(members[6], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -18122,7 +16681,7 @@ class _ResponseStreamDeserializer: def deserialize(self, deserializer: ShapeDeserializer) -> ResponseStream: self._result = None - deserializer.read_struct(_SCHEMA_RESPONSE_STREAM, self._consumer) + deserializer.read_struct(hydrate(_SCHEMA_RESPONSE_STREAM), self._consumer) if self._result is None: raise SerializationError( @@ -18193,26 +16752,20 @@ class InvokeModelWithResponseStreamOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_INVOKE_MODEL_WITH_RESPONSE_STREAM_OUTPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_INVOKE_MODEL_WITH_RESPONSE_STREAM_OUTPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_string( - _SCHEMA_INVOKE_MODEL_WITH_RESPONSE_STREAM_OUTPUT.members["contentType"], - self.content_type, - ) + members = hydrate( + _SCHEMA_INVOKE_MODEL_WITH_RESPONSE_STREAM_OUTPUT + ).members_by_index + serializer.write_string(members[1], self.content_type) if self.performance_config_latency is not None: - serializer.write_string( - _SCHEMA_INVOKE_MODEL_WITH_RESPONSE_STREAM_OUTPUT.members[ - "performanceConfigLatency" - ], - self.performance_config_latency, - ) + serializer.write_string(members[2], self.performance_config_latency) if self.service_tier is not None: - serializer.write_string( - _SCHEMA_INVOKE_MODEL_WITH_RESPONSE_STREAM_OUTPUT.members["serviceTier"], - self.service_tier, - ) + serializer.write_string(members[3], self.service_tier) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -18221,40 +16774,26 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_INVOKE_MODEL_WITH_RESPONSE_STREAM_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 1: - kwargs["content_type"] = de.read_string( - _SCHEMA_INVOKE_MODEL_WITH_RESPONSE_STREAM_OUTPUT.members[ - "contentType" - ] - ) + kwargs["content_type"] = de.read_string(members[1]) case 2: kwargs["performance_config_latency"] = PerformanceConfigLatency( - de.read_string( - _SCHEMA_INVOKE_MODEL_WITH_RESPONSE_STREAM_OUTPUT.members[ - "performanceConfigLatency" - ] - ) + de.read_string(members[2]) ) case 3: - kwargs["service_tier"] = ServiceTierType( - de.read_string( - _SCHEMA_INVOKE_MODEL_WITH_RESPONSE_STREAM_OUTPUT.members[ - "serviceTier" - ] - ) - ) + kwargs["service_tier"] = ServiceTierType(de.read_string(members[3])) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_INVOKE_MODEL_WITH_RESPONSE_STREAM_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) if "content_type" not in kwargs: kwargs["content_type"] = "" return kwargs @@ -18263,9 +16802,7 @@ def _consumer(schema: Schema, de: ShapeDeserializer) -> None: INVOKE_MODEL_WITH_RESPONSE_STREAM = APIOperation( input=InvokeModelWithResponseStreamInput, output=InvokeModelWithResponseStreamOutput, - schema=_SCHEMA_INVOKE_MODEL_WITH_RESPONSE_STREAM, - input_schema=_SCHEMA_INVOKE_MODEL_WITH_RESPONSE_STREAM_INPUT, - output_schema=_SCHEMA_INVOKE_MODEL_WITH_RESPONSE_STREAM_OUTPUT, + static_schema=_SCHEMA_INVOKE_MODEL_WITH_RESPONSE_STREAM, error_registry=TypeRegistry( { ShapeID( @@ -18307,19 +16844,6 @@ def _consumer(schema: Schema, de: ShapeDeserializer) -> None: ShapeID("aws.auth#sigv4"), ShapeID("smithy.api#httpBearerAuth"), ], - error_schemas=[ - _SCHEMA_ACCESS_DENIED_EXCEPTION, - _SCHEMA_INTERNAL_SERVER_EXCEPTION, - _SCHEMA_MODEL_ERROR_EXCEPTION, - _SCHEMA_MODEL_NOT_READY_EXCEPTION, - _SCHEMA_MODEL_STREAM_ERROR_EXCEPTION, - _SCHEMA_MODEL_TIMEOUT_EXCEPTION, - _SCHEMA_RESOURCE_NOT_FOUND_EXCEPTION, - _SCHEMA_SERVICE_QUOTA_EXCEEDED_EXCEPTION, - _SCHEMA_SERVICE_UNAVAILABLE_EXCEPTION, - _SCHEMA_THROTTLING_EXCEPTION, - _SCHEMA_VALIDATION_EXCEPTION, - ], ) @@ -18357,33 +16881,21 @@ class ConverseTokensRequest: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_CONVERSE_TOKENS_REQUEST, self) + serializer.write_struct(hydrate(_SCHEMA_CONVERSE_TOKENS_REQUEST), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_CONVERSE_TOKENS_REQUEST).members_by_index if self.messages is not None: - _serialize_messages( - serializer, - _SCHEMA_CONVERSE_TOKENS_REQUEST.members["messages"], - self.messages, - ) + _serialize_messages(serializer, members[0], self.messages) if self.system is not None: - _serialize_system_content_blocks( - serializer, - _SCHEMA_CONVERSE_TOKENS_REQUEST.members["system"], - self.system, - ) + _serialize_system_content_blocks(serializer, members[1], self.system) if self.tool_config is not None: - serializer.write_struct( - _SCHEMA_CONVERSE_TOKENS_REQUEST.members["toolConfig"], self.tool_config - ) + serializer.write_struct(members[2], self.tool_config) if self.additional_model_request_fields is not None: - serializer.write_document( - _SCHEMA_CONVERSE_TOKENS_REQUEST.members["additionalModelRequestFields"], - self.additional_model_request_fields, - ) + serializer.write_document(members[3], self.additional_model_request_fields) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -18392,17 +16904,17 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_CONVERSE_TOKENS_REQUEST) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["messages"] = _deserialize_messages( - de, _SCHEMA_CONVERSE_TOKENS_REQUEST.members["messages"] - ) + kwargs["messages"] = _deserialize_messages(de, members[0]) case 1: kwargs["system"] = _deserialize_system_content_blocks( - de, _SCHEMA_CONVERSE_TOKENS_REQUEST.members["system"] + de, members[1] ) case 2: @@ -18410,15 +16922,13 @@ def _consumer(schema: Schema, de: ShapeDeserializer) -> None: case 3: kwargs["additional_model_request_fields"] = de.read_document( - _SCHEMA_CONVERSE_TOKENS_REQUEST.members[ - "additionalModelRequestFields" - ] + members[3] ) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_CONVERSE_TOKENS_REQUEST, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -18439,12 +16949,11 @@ class InvokeModelTokensRequest: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_INVOKE_MODEL_TOKENS_REQUEST, self) + serializer.write_struct(hydrate(_SCHEMA_INVOKE_MODEL_TOKENS_REQUEST), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_blob( - _SCHEMA_INVOKE_MODEL_TOKENS_REQUEST.members["body"], self.body - ) + members = hydrate(_SCHEMA_INVOKE_MODEL_TOKENS_REQUEST).members_by_index + serializer.write_blob(members[0], self.body) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -18453,20 +16962,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_INVOKE_MODEL_TOKENS_REQUEST) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["body"] = de.read_blob( - _SCHEMA_INVOKE_MODEL_TOKENS_REQUEST.members["body"] - ) + kwargs["body"] = de.read_blob(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_INVOKE_MODEL_TOKENS_REQUEST, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) if "body" not in kwargs: kwargs["body"] = b"" return kwargs @@ -18483,12 +16990,11 @@ class CountTokensInputInvokeModel: value: InvokeModelTokensRequest def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_COUNT_TOKENS_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_COUNT_TOKENS_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_struct( - _SCHEMA_COUNT_TOKENS_INPUT.members["invokeModel"], self.value - ) + members = hydrate(_SCHEMA_COUNT_TOKENS_INPUT).members_by_index + serializer.write_struct(members[0], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -18506,12 +17012,11 @@ class CountTokensInputConverse: value: ConverseTokensRequest def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_COUNT_TOKENS_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_COUNT_TOKENS_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_struct( - _SCHEMA_COUNT_TOKENS_INPUT.members["converse"], self.value - ) + members = hydrate(_SCHEMA_COUNT_TOKENS_INPUT).members_by_index + serializer.write_struct(members[1], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -18556,7 +17061,7 @@ class _CountTokensInputDeserializer: def deserialize(self, deserializer: ShapeDeserializer) -> CountTokensInput: self._result = None - deserializer.read_struct(_SCHEMA_COUNT_TOKENS_INPUT, self._consumer) + deserializer.read_struct(hydrate(_SCHEMA_COUNT_TOKENS_INPUT), self._consumer) if self._result is None: raise SerializationError( @@ -18614,18 +17119,15 @@ class CountTokensOperationInput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_COUNT_TOKENS_OPERATION_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_COUNT_TOKENS_OPERATION_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_COUNT_TOKENS_OPERATION_INPUT).members_by_index if self.model_id is not None: - serializer.write_string( - _SCHEMA_COUNT_TOKENS_OPERATION_INPUT.members["modelId"], self.model_id - ) + serializer.write_string(members[0], self.model_id) if self.input is not None: - serializer.write_struct( - _SCHEMA_COUNT_TOKENS_OPERATION_INPUT.members["input"], self.input - ) + serializer.write_struct(members[1], self.input) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -18634,23 +17136,21 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_COUNT_TOKENS_OPERATION_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["model_id"] = de.read_string( - _SCHEMA_COUNT_TOKENS_OPERATION_INPUT.members["modelId"] - ) + kwargs["model_id"] = de.read_string(members[0]) case 1: kwargs["input"] = _CountTokensInputDeserializer().deserialize(de) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_COUNT_TOKENS_OPERATION_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -18678,12 +17178,11 @@ class CountTokensOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_COUNT_TOKENS_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_COUNT_TOKENS_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_integer( - _SCHEMA_COUNT_TOKENS_OUTPUT.members["inputTokens"], self.input_tokens - ) + members = hydrate(_SCHEMA_COUNT_TOKENS_OUTPUT).members_by_index + serializer.write_integer(members[0], self.input_tokens) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -18692,18 +17191,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_COUNT_TOKENS_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["input_tokens"] = de.read_integer( - _SCHEMA_COUNT_TOKENS_OUTPUT.members["inputTokens"] - ) + kwargs["input_tokens"] = de.read_integer(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_COUNT_TOKENS_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) if "input_tokens" not in kwargs: kwargs["input_tokens"] = 0 return kwargs @@ -18712,9 +17211,7 @@ def _consumer(schema: Schema, de: ShapeDeserializer) -> None: COUNT_TOKENS = APIOperation( input=CountTokensOperationInput, output=CountTokensOutput, - schema=_SCHEMA_COUNT_TOKENS, - input_schema=_SCHEMA_COUNT_TOKENS_OPERATION_INPUT, - output_schema=_SCHEMA_COUNT_TOKENS_OUTPUT, + static_schema=_SCHEMA_COUNT_TOKENS, error_registry=TypeRegistry( { ShapeID( @@ -18741,12 +17238,4 @@ def _consumer(schema: Schema, de: ShapeDeserializer) -> None: ShapeID("aws.auth#sigv4"), ShapeID("smithy.api#httpBearerAuth"), ], - error_schemas=[ - _SCHEMA_ACCESS_DENIED_EXCEPTION, - _SCHEMA_INTERNAL_SERVER_EXCEPTION, - _SCHEMA_RESOURCE_NOT_FOUND_EXCEPTION, - _SCHEMA_SERVICE_UNAVAILABLE_EXCEPTION, - _SCHEMA_THROTTLING_EXCEPTION, - _SCHEMA_VALIDATION_EXCEPTION, - ], ) diff --git a/clients/aws-sdk-bedrock-runtime/tests/test_request_compression.py b/clients/aws-sdk-bedrock-runtime/tests/test_request_compression.py new file mode 100644 index 00000000..f4020ceb --- /dev/null +++ b/clients/aws-sdk-bedrock-runtime/tests/test_request_compression.py @@ -0,0 +1,182 @@ +# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. +# SPDX-License-Identifier: Apache-2.0 + +from pathlib import Path +from typing import Unpack + +import pytest +from smithy_core import URI +from smithy_core.aio.types import AsyncBytesReader +from smithy_core.exceptions import SmithyError +from smithy_core.types import TypedProperties +from smithy_http.testing import MockHTTPClient + +from aws_sdk_bedrock_runtime.client import AsyncBedrockRuntimeClient +from aws_sdk_bedrock_runtime.config import ( + AsyncBedrockRuntimeConfig, + _AsyncBedrockRuntimeConfigOverrides, +) +from aws_sdk_bedrock_runtime.models import ( + CONVERSE, + CONVERSE_STREAM, + INVOKE_MODEL, + INVOKE_MODEL_WITH_RESPONSE_STREAM, + ContentBlockText, + ConverseInput, + ConverseStreamInput, + InvokeModelInput, + InvokeModelWithResponseStreamInput, + Message, +) + + +@pytest.fixture(autouse=True) +def isolate_aws_compression_environment(monkeypatch: pytest.MonkeyPatch) -> None: + for variable in ( + "AWS_DISABLE_REQUEST_COMPRESSION", + "AWS_REQUEST_MIN_COMPRESSION_SIZE_BYTES", + "AWS_PROFILE", + "AWS_DEFAULT_PROFILE", + ): + monkeypatch.delenv(variable, raising=False) + + +async def resolve_config( + tmp_path: Path, **overrides: Unpack[_AsyncBedrockRuntimeConfigOverrides] +) -> AsyncBedrockRuntimeConfig: + resolved_overrides: _AsyncBedrockRuntimeConfigOverrides = { + "region": "us-west-2", + "transport": MockHTTPClient(), + **overrides, + } + return await AsyncBedrockRuntimeConfig.resolve( + config_file_path=str(tmp_path / "config"), + credentials_file_path=str(tmp_path / "credentials"), + **resolved_overrides, + ) + + +async def test_compression_defaults_are_available_on_generated_config( + tmp_path: Path, +) -> None: + config = await resolve_config(tmp_path) + assert config.disable_request_compression is False + assert config.request_min_compression_size_bytes == 10240 + assert config.request_compression_encoding is None + + +async def test_explicit_gzip_survives_generated_config_resolution( + tmp_path: Path, +) -> None: + config = await resolve_config( + tmp_path, + request_compression_encoding="gzip", + request_min_compression_size_bytes=10485760, + ) + assert config.request_compression_encoding == "gzip" + assert config.request_min_compression_size_bytes == 10485760 + + +async def test_standard_compression_settings_resolve_from_environment( + tmp_path: Path, monkeypatch: pytest.MonkeyPatch +) -> None: + monkeypatch.setenv("AWS_DISABLE_REQUEST_COMPRESSION", "true") + monkeypatch.setenv("AWS_REQUEST_MIN_COMPRESSION_SIZE_BYTES", "256") + config = await resolve_config(tmp_path) + assert config.disable_request_compression is True + assert config.request_min_compression_size_bytes == 256 + + +async def test_explicit_settings_override_environment( + tmp_path: Path, monkeypatch: pytest.MonkeyPatch +) -> None: + monkeypatch.setenv("AWS_DISABLE_REQUEST_COMPRESSION", "true") + monkeypatch.setenv("AWS_REQUEST_MIN_COMPRESSION_SIZE_BYTES", "256") + config = await resolve_config( + tmp_path, + disable_request_compression=False, + request_min_compression_size_bytes=0, + request_compression_encoding="gzip", + ) + assert config.disable_request_compression is False + assert config.request_min_compression_size_bytes == 0 + assert config.request_compression_encoding == "gzip" + + +@pytest.mark.parametrize( + "kind", ["converse", "converse-stream", "invoke", "invoke-with-response-stream"] +) +async def test_default_bedrock_request_stays_uncompressed( + tmp_path: Path, kind: str +) -> None: + config = await resolve_config(tmp_path) + assert config.protocol is not None + messages = [Message(role="user", content=[ContentBlockText(value="hello")])] + if kind == "converse": + operation, input = ( + CONVERSE, + ConverseInput(model_id="test-model", messages=messages), + ) + elif kind == "converse-stream": + operation, input = ( + CONVERSE_STREAM, + ConverseStreamInput(model_id="test-model", messages=messages), + ) + elif kind == "invoke": + operation, input = ( + INVOKE_MODEL, + InvokeModelInput( + model_id="test-model", + body=b'{"prompt":"hello"}', + content_type="application/json", + ), + ) + else: + operation, input = ( + INVOKE_MODEL_WITH_RESPONSE_STREAM, + InvokeModelWithResponseStreamInput( + model_id="test-model", + body=b'{"prompt":"hello"}', + content_type="application/json", + ), + ) + request = config.protocol.serialize_request( + operation=operation, + input=input, + endpoint=URI(host="bedrock-runtime.us-west-2.amazonaws.com"), + context=TypedProperties({"config": config}), + ) + assert "Content-Encoding" not in request.fields + assert request.method == "POST" + assert request.destination.path == f"/model/test-model/{kind}" + assert request.fields["Content-Type"].as_string() == "application/json" + wire = await AsyncBytesReader(request.body).read() + if kind.startswith("converse"): + assert wire == b'{"messages":[{"role":"user","content":[{"text":"hello"}]}]}' + else: + assert wire == b'{"prompt":"hello"}' + + +async def test_explicit_gzip_rejects_unmodeled_bedrock_before_signing( + tmp_path: Path, +) -> None: + config = await resolve_config(tmp_path, request_compression_encoding="gzip") + assert config.protocol is not None + with pytest.raises(ValueError, match=r"Converse.*gzip|gzip.*Converse"): + config.protocol.serialize_request( + operation=CONVERSE, + input=ConverseInput(model_id="test-model"), + endpoint=URI(host="bedrock-runtime.us-west-2.amazonaws.com"), + context=TypedProperties({"config": config}), + ) + + +async def test_explicit_gzip_client_call_fails_before_transport(tmp_path: Path) -> None: + transport = MockHTTPClient() + config = await resolve_config( + tmp_path, request_compression_encoding="gzip", transport=transport + ) + async with AsyncBedrockRuntimeClient(config=config) as client: + with pytest.raises(SmithyError, match=r"Converse.*gzip|gzip.*Converse"): + await client.converse(ConverseInput(model_id="test-model")) + assert transport.captured_requests == []