From 73a81b9fe228d8cf2b63ac49c82df379362434ca Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Gabriel=20Silva=20Gouv=C3=AAa?= <64869705+gouveags@users.noreply.github.com> Date: Sun, 18 Oct 2026 20:29:01 -0300 Subject: [PATCH 1/4] Regenerate Bedrock Runtime for compact Smithy schemas --- ...ment-9c8ffa23c5a94db3beea927d3b754f6e.json | 4 + .../_private/schemas.py | 7574 ++++++++--------- .../src/aws_sdk_bedrock_runtime/models.py | 6879 ++++++--------- 3 files changed, 6449 insertions(+), 8008 deletions(-) create mode 100644 clients/aws-sdk-bedrock-runtime/.changes/next-release/aws-sdk-bedrock-runtime-enhancement-9c8ffa23c5a94db3beea927d3b754f6e.json 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/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, - ], ) From 1cd64afc87a1d06988428260c9e9bd50b4e2f687 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Gabriel=20Silva=20Gouv=C3=AAa?= <64869705+gouveags@users.noreply.github.com> Date: Sun, 18 Oct 2026 20:29:01 -0300 Subject: [PATCH 2/4] Document and test shared request compression adoption --- ...ture-0215e886f8084bdd9303da46e8740056.json | 4 + clients/aws-sdk-bedrock-runtime/README.md | 36 ++++ .../tests/test_request_compression.py | 182 ++++++++++++++++++ 3 files changed, 222 insertions(+) create mode 100644 clients/aws-sdk-bedrock-runtime/.changes/next-release/aws-sdk-bedrock-runtime-feature-0215e886f8084bdd9303da46e8740056.json create mode 100644 clients/aws-sdk-bedrock-runtime/tests/test_request_compression.py 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/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 == [] From a5b3000548559f2da2c767ad968839961d8fb6f6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Gabriel=20Silva=20Gouv=C3=AAa?= <64869705+gouveags@users.noreply.github.com> Date: Mon, 26 Oct 2026 10:27:27 -0300 Subject: [PATCH 3/4] Align request compression adoption with standard SDK controls --- ...ture-0215e886f8084bdd9303da46e8740056.json | 2 +- clients/aws-sdk-bedrock-runtime/README.md | 17 +++--- .../tests/test_request_compression.py | 56 +++++-------------- 3 files changed, 23 insertions(+), 52 deletions(-) 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 index 7c70e301..ecdd4d93 100644 --- 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 @@ -1,4 +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." + "description": "Document and validate standard request-compression thresholds and disable controls inherited from the shared runtime. Current Bedrock operations remain uncompressed because their service model does not advertise support." } diff --git a/clients/aws-sdk-bedrock-runtime/README.md b/clients/aws-sdk-bedrock-runtime/README.md index bdea74d9..c24b43ee 100644 --- a/clients/aws-sdk-bedrock-runtime/README.md +++ b/clients/aws-sdk-bedrock-runtime/README.md @@ -22,31 +22,28 @@ python -m pip install aws-sdk-bedrock-runtime ## 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 +gzip support. It does not reduce model input tokens. The client exposes two 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. + defaulting to 10,240 bytes, with an accepted range of 0 through 10,485,760. -For an operation with advertised gzip support, explicit configuration is: +For operations with advertised gzip support, set the threshold to zero to +compress eligible buffered requests regardless of size: ```python from aws_sdk_bedrock_runtime.config import AsyncBedrockRuntimeConfig config = await AsyncBedrockRuntimeConfig.resolve( region="us-east-1", - request_compression_encoding="gzip", + request_min_compression_size_bytes=0, ) ``` 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. +Current Bedrock operations therefore remain uncompressed, even with a zero +threshold. 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 diff --git a/clients/aws-sdk-bedrock-runtime/tests/test_request_compression.py b/clients/aws-sdk-bedrock-runtime/tests/test_request_compression.py index f4020ceb..bae326a5 100644 --- a/clients/aws-sdk-bedrock-runtime/tests/test_request_compression.py +++ b/clients/aws-sdk-bedrock-runtime/tests/test_request_compression.py @@ -7,11 +7,9 @@ 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, @@ -62,19 +60,16 @@ async def test_compression_defaults_are_available_on_generated_config( 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, +@pytest.mark.parametrize("minimum_size", [0, 10485760]) +async def test_compression_threshold_boundaries_survive_generated_config_resolution( + tmp_path: Path, minimum_size: int ) -> None: config = await resolve_config( - tmp_path, - request_compression_encoding="gzip", - request_min_compression_size_bytes=10485760, + tmp_path, request_min_compression_size_bytes=minimum_size ) - assert config.request_compression_encoding == "gzip" - assert config.request_min_compression_size_bytes == 10485760 + assert config.request_min_compression_size_bytes == minimum_size async def test_standard_compression_settings_resolve_from_environment( @@ -87,7 +82,7 @@ async def test_standard_compression_settings_resolve_from_environment( assert config.request_min_compression_size_bytes == 256 -async def test_explicit_settings_override_environment( +async def test_client_settings_override_environment( tmp_path: Path, monkeypatch: pytest.MonkeyPatch ) -> None: monkeypatch.setenv("AWS_DISABLE_REQUEST_COMPRESSION", "true") @@ -96,20 +91,24 @@ async def test_explicit_settings_override_environment( 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 +@pytest.mark.parametrize("minimum_size", [None, 0]) +async def test_unsupported_bedrock_request_stays_uncompressed( + tmp_path: Path, kind: str, minimum_size: int | None ) -> None: - config = await resolve_config(tmp_path) + if minimum_size is None: + config = await resolve_config(tmp_path) + else: + config = await resolve_config( + tmp_path, request_min_compression_size_bytes=minimum_size + ) assert config.protocol is not None messages = [Message(role="user", content=[ContentBlockText(value="hello")])] if kind == "converse": @@ -155,28 +154,3 @@ async def test_default_bedrock_request_stays_uncompressed( 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 == [] From d9ad0b2e9a820eeda5b37a574443d5dd0690b3b1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Gabriel=20Silva=20Gouv=C3=AAa?= <64869705+gouveags@users.noreply.github.com> Date: Mon, 26 Oct 2026 11:54:50 -0300 Subject: [PATCH 4/4] Keep compression adoption separate from generated client migration --- ...ment-9c8ffa23c5a94db3beea927d3b754f6e.json | 4 - clients/aws-sdk-bedrock-runtime/README.md | 5 + .../_private/schemas.py | 7576 +++++++++-------- .../src/aws_sdk_bedrock_runtime/models.py | 6875 +++++++++------ 4 files changed, 8012 insertions(+), 6448 deletions(-) delete mode 100644 clients/aws-sdk-bedrock-runtime/.changes/next-release/aws-sdk-bedrock-runtime-enhancement-9c8ffa23c5a94db3beea927d3b754f6e.json 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 deleted file mode 100644 index f3721eb4..00000000 --- a/clients/aws-sdk-bedrock-runtime/.changes/next-release/aws-sdk-bedrock-runtime-enhancement-9c8ffa23c5a94db3beea927d3b754f6e.json +++ /dev/null @@ -1,4 +0,0 @@ -{ - "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/README.md b/clients/aws-sdk-bedrock-runtime/README.md index c24b43ee..b363b964 100644 --- a/clients/aws-sdk-bedrock-runtime/README.md +++ b/clients/aws-sdk-bedrock-runtime/README.md @@ -21,6 +21,11 @@ python -m pip install aws-sdk-bedrock-runtime ## Request compression +> **Pending upstream support:** This integration requires a Smithy runtime release +> containing [request compression](https://github.com/smithy-lang/smithy-python/pull/855) +> and the normal client regeneration/dependency update. The configuration below +> is not available with the currently declared dependencies. + Request compression reduces the bytes uploaded to an operation that advertises gzip support. It does not reduce model input tokens. The client exposes two configuration settings: 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 4a07d939..e7478788 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,4114 +2,4166 @@ from types import MappingProxyType -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.prelude import ( + BLOB, + BOOLEAN, + DOCUMENT, + DOUBLE, + FLOAT, + INTEGER, + LONG, + STRING, + UNIT, ) +from smithy_core.schemas import Schema +from smithy_core.shapes import ShapeID, ShapeType +from smithy_core.traits import Trait -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, - ), + +NON_BLANK_STRING = Schema( + id=ShapeID("com.amazonaws.bedrockruntime#NonBlankString"), + shape_type=ShapeType.STRING, ) -MAX_RESULTS: StaticSchema = (7, n0, _MR, 0) +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}}, +) -PAGINATION_TOKEN: StaticSchema = (3, n0, _PT, 0) +ACCOUNT_ID = Schema( + id=ShapeID("com.amazonaws.bedrockruntime#AccountId"), shape_type=ShapeType.STRING +) -SORT_ASYNC_INVOCATION_BY: StaticSchema = (14, n0, _SAIB, 0, (_ST,), ((-1, 0),)) +ADDITIONAL_MODEL_RESPONSE_FIELD_PATHS = Schema.collection( + id=ShapeID("com.amazonaws.bedrockruntime#AdditionalModelResponseFieldPaths"), + shape_type=ShapeType.LIST, + members={"member": {"target": STRING}}, +) -SORT_ORDER: StaticSchema = ( - 14, - n0, - _SO, - 0, - (_ASCENDING, _DESCENDING), - ((-1, 0), (-1, 0)), +INVOCATION_ARN = Schema( + id=ShapeID("com.amazonaws.bedrockruntime#InvocationArn"), + shape_type=ShapeType.STRING, ) -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}), - ), +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")), + ], + } + }, ) -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), - ), +ASYNC_INVOKE_IDEMPOTENCY_TOKEN = Schema( + id=ShapeID("com.amazonaws.bedrockruntime#AsyncInvokeIdempotencyToken"), + shape_type=ShapeType.STRING, ) -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, - ), +TIMESTAMP = Schema( + id=ShapeID("com.amazonaws.bedrockruntime#Timestamp"), + shape_type=ShapeType.TIMESTAMP, + traits=[Trait.new(id=ShapeID("smithy.api#timestampFormat"), value="date-time")], ) -CONFLICT_EXCEPTION: StaticSchema = ( - 18, - n0, - _CE, - {_s: _c, _sE: 400}, - (_m,), - ((NON_BLANK_STRING, 0),), +ASYNC_INVOKE_MESSAGE = Schema( + id=ShapeID("com.amazonaws.bedrockruntime#AsyncInvokeMessage"), + shape_type=ShapeType.STRING, + traits=[Trait.new(id=ShapeID("smithy.api#sensitive"))], ) -RESOURCE_NOT_FOUND_EXCEPTION: StaticSchema = ( - 18, - n0, - _RNFE, - {_s: _c, _sE: 404}, - (_m,), - ((NON_BLANK_STRING, 0),), +ASYNC_INVOKE_ARN = Schema( + id=ShapeID("com.amazonaws.bedrockruntime#AsyncInvokeArn"), + shape_type=ShapeType.STRING, ) -SERVICE_QUOTA_EXCEEDED_EXCEPTION: StaticSchema = ( - 18, - n0, - _SQEE, - {_s: _c, _sE: 400}, - (_m,), - ((NON_BLANK_STRING, 0),), +KMS_KEY_ID = Schema( + id=ShapeID("com.amazonaws.bedrockruntime#KmsKeyId"), shape_type=ShapeType.STRING ) -SERVICE_UNAVAILABLE_EXCEPTION: StaticSchema = ( - 18, - n0, - _SUE, - {_s: _se, _sE: 503}, - (_m,), - ((NON_BLANK_STRING, 0),), +S3_URI = Schema( + id=ShapeID("com.amazonaws.bedrockruntime#S3Uri"), shape_type=ShapeType.STRING ) -ASYNC_INVOKE_IDENTIFIER: StaticSchema = (3, n0, _AII, 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}, + }, +) -MODEL_INPUT_PAYLOAD: StaticSchema = (13, n0, _MIP, 4) +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}}, +) -TAG_KEY: StaticSchema = (3, n0, _TK, 0) +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_VALUE: StaticSchema = (3, n0, _TV, 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: StaticSchema = (18, n0, _Ta, 0, (_k, _v), ((TAG_KEY, 1), (TAG_VALUE, 1))) +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_LIST: StaticSchema = (16, n0, _TL, 0, (_me,), ((TAG, 0),)) +MAX_RESULTS = Schema( + id=ShapeID("com.amazonaws.bedrockruntime#MaxResults"), shape_type=ShapeType.INTEGER +) -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), - ), +PAGINATION_TOKEN = Schema( + id=ShapeID("com.amazonaws.bedrockruntime#PaginationToken"), + shape_type=ShapeType.STRING, ) -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_ASYNC_INVOCATION_BY = Schema.collection( + id=ShapeID("com.amazonaws.bedrockruntime#SortAsyncInvocationBy"), + shape_type=ShapeType.ENUM, + members={"SUBMISSION_TIME": {"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), - ), +SORT_ORDER = Schema.collection( + id=ShapeID("com.amazonaws.bedrockruntime#SortOrder"), + shape_type=ShapeType.ENUM, + members={"ASCENDING": {"target": UNIT}, "DESCENDING": {"target": UNIT}}, ) -GUARDRAIL_ACTION: StaticSchema = (14, n0, _GA, 0, (_NONE, _GI_), ((-1, 0), (-1, 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_ARN: StaticSchema = (3, n0, _GAu, 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_ID: StaticSchema = (3, n0, _GIu, 0) +ASYNC_INVOKE_SUMMARIES = Schema.collection( + id=ShapeID("com.amazonaws.bedrockruntime#AsyncInvokeSummaries"), + shape_type=ShapeType.LIST, + members={"member": {"target": ASYNC_INVOKE_SUMMARY}}, +) -GUARDRAIL_ORIGIN: StaticSchema = ( - 14, - n0, - _GO, - 0, - (_REQUEST, _AE, _OE), - ((-1, 0), (-1, 0), (-1, 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_LIST: StaticSchema = ( - 16, - n0, - _GOL, - 0, - (_me,), - ((GUARDRAIL_ORIGIN, 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_OWNERSHIP: StaticSchema = (14, n0, _GOu, 0, (_SELF, _CA), ((-1, 0), (-1, 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}}, +) -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), - ), +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}}, ) -AUTOMATED_REASONING_RULE_IDENTIFIER: StaticSchema = (3, n0, _ARRI, 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}}, +) -GUARDRAIL_AUTOMATED_REASONING_POLICY_VERSION_ARN: StaticSchema = (3, n0, _GARPVA, 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_RULE: StaticSchema = ( - 18, - n0, - _GARR, - 0, - (_id, _pVA), - ( - (AUTOMATED_REASONING_RULE_IDENTIFIER, 0), - (GUARDRAIL_AUTOMATED_REASONING_POLICY_VERSION_ARN, 0), - ), +ASYNC_INVOKE_IDENTIFIER = Schema( + id=ShapeID("com.amazonaws.bedrockruntime#AsyncInvokeIdentifier"), + shape_type=ShapeType.STRING, ) -GUARDRAIL_AUTOMATED_REASONING_RULE_LIST: StaticSchema = ( - 16, - n0, - _GARRL, - 0, - (_me,), - ((GUARDRAIL_AUTOMATED_REASONING_RULE, 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_STATEMENT_LOGIC_CONTENT: StaticSchema = ( - 3, - n0, - _GARSLC, - 4, +TAG_KEY = Schema( + id=ShapeID("com.amazonaws.bedrockruntime#TagKey"), shape_type=ShapeType.STRING ) -GUARDRAIL_AUTOMATED_REASONING_STATEMENT_NATURAL_LANGUAGE_CONTENT: StaticSchema = ( - 3, - n0, - _GARSNLC, - 4, +TAG_VALUE = Schema( + id=ShapeID("com.amazonaws.bedrockruntime#TagValue"), shape_type=ShapeType.STRING ) -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 = 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_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), - ), +TAG_LIST = Schema.collection( + id=ShapeID("com.amazonaws.bedrockruntime#TagList"), + shape_type=ShapeType.LIST, + members={"member": {"target": TAG}}, ) -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_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_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_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_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), - ), +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_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 = 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_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_CONTENT_QUALIFIER_LIST = Schema.collection( + id=ShapeID("com.amazonaws.bedrockruntime#GuardrailContentQualifierList"), + shape_type=ShapeType.LIST, + members={"member": {"target": GUARDRAIL_CONTENT_QUALIFIER}}, ) -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_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_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 = 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_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_CONTENT_BLOCK_LIST = Schema.collection( + id=ShapeID("com.amazonaws.bedrockruntime#GuardrailContentBlockList"), + shape_type=ShapeType.LIST, + members={"member": {"target": GUARDRAIL_CONTENT_BLOCK}}, ) -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_IDENTIFIER = Schema( + id=ShapeID("com.amazonaws.bedrockruntime#GuardrailIdentifier"), + shape_type=ShapeType.STRING, ) -GUARDRAIL_CONTEXTUAL_GROUNDING_FILTERS: StaticSchema = ( - 16, - n0, - _GCGFu, - 0, - (_me,), - ((GUARDRAIL_CONTEXTUAL_GROUNDING_FILTER, 0),), +GUARDRAIL_VERSION = Schema( + id=ShapeID("com.amazonaws.bedrockruntime#GuardrailVersion"), + shape_type=ShapeType.STRING, ) -GUARDRAIL_CONTEXTUAL_GROUNDING_POLICY_ASSESSMENT: StaticSchema = ( - 18, - n0, - _GCGPAu, - 0, - (_fil,), - ((GUARDRAIL_CONTEXTUAL_GROUNDING_FILTERS, 0),), +GUARDRAIL_OUTPUT_SCOPE = Schema.collection( + id=ShapeID("com.amazonaws.bedrockruntime#GuardrailOutputScope"), + shape_type=ShapeType.ENUM, + members={"INTERVENTIONS": {"target": UNIT}, "FULL": {"target": UNIT}}, ) -IMAGES_GUARDED: StaticSchema = (7, n0, _IG, 0) +GUARDRAIL_CONTENT_SOURCE = Schema.collection( + id=ShapeID("com.amazonaws.bedrockruntime#GuardrailContentSource"), + shape_type=ShapeType.ENUM, + members={"INPUT": {"target": UNIT}, "OUTPUT": {"target": UNIT}}, +) -IMAGES_TOTAL: StaticSchema = (7, n0, _IT, 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}, + }, +) -GUARDRAIL_IMAGE_COVERAGE: StaticSchema = ( - 18, - n0, - _GIC, - 0, - (_g, _to), - ((IMAGES_GUARDED, 0), (IMAGES_TOTAL, 0)), +GUARDRAIL_ACTION = Schema.collection( + id=ShapeID("com.amazonaws.bedrockruntime#GuardrailAction"), + shape_type=ShapeType.ENUM, + members={"NONE": {"target": UNIT}, "GUARDRAIL_INTERVENED": {"target": UNIT}}, ) -TEXT_CHARACTERS_GUARDED: StaticSchema = (7, n0, _TCG, 0) +GUARDRAIL_ARN = Schema( + id=ShapeID("com.amazonaws.bedrockruntime#GuardrailArn"), shape_type=ShapeType.STRING +) -TEXT_CHARACTERS_TOTAL: StaticSchema = (7, n0, _TCT, 0) +GUARDRAIL_ID = Schema( + id=ShapeID("com.amazonaws.bedrockruntime#GuardrailId"), shape_type=ShapeType.STRING +) -GUARDRAIL_TEXT_CHARACTERS_COVERAGE: StaticSchema = ( - 18, - n0, - _GTCC, - 0, - (_g, _to), - ((TEXT_CHARACTERS_GUARDED, 0), (TEXT_CHARACTERS_TOTAL, 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_COVERAGE: StaticSchema = ( - 18, - n0, - _GCu, - 0, - (_tCe, _ima), - ((GUARDRAIL_TEXT_CHARACTERS_COVERAGE, 0), (GUARDRAIL_IMAGE_COVERAGE, 0)), +GUARDRAIL_ORIGIN_LIST = Schema.collection( + id=ShapeID("com.amazonaws.bedrockruntime#GuardrailOriginList"), + shape_type=ShapeType.LIST, + members={"member": {"target": GUARDRAIL_ORIGIN}}, ) -GUARDRAIL_PROCESSING_LATENCY: StaticSchema = (8, n0, _GPL, 0) +GUARDRAIL_OWNERSHIP = Schema.collection( + id=ShapeID("com.amazonaws.bedrockruntime#GuardrailOwnership"), + shape_type=ShapeType.ENUM, + members={"SELF": {"target": UNIT}, "CROSS_ACCOUNT": {"target": UNIT}}, +) -GUARDRAIL_AUTOMATED_REASONING_POLICIES_PROCESSED: StaticSchema = (7, n0, _GARPP, 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_POLICY_UNITS_PROCESSED: StaticSchema = (7, n0, _GARPUP, 0) +AUTOMATED_REASONING_RULE_IDENTIFIER = Schema( + id=ShapeID("com.amazonaws.bedrockruntime#AutomatedReasoningRuleIdentifier"), + shape_type=ShapeType.STRING, +) -GUARDRAIL_CONTENT_POLICY_IMAGE_UNITS_PROCESSED: StaticSchema = (7, n0, _GCPIUP, 0) +GUARDRAIL_AUTOMATED_REASONING_POLICY_VERSION_ARN = Schema( + id=ShapeID( + "com.amazonaws.bedrockruntime#GuardrailAutomatedReasoningPolicyVersionArn" + ), + shape_type=ShapeType.STRING, +) -GUARDRAIL_CONTENT_POLICY_UNITS_PROCESSED: StaticSchema = (7, n0, _GCPUP, 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_CONTEXTUAL_GROUNDING_POLICY_UNITS_PROCESSED: StaticSchema = ( - 7, - n0, - _GCGPUP, - 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_SENSITIVE_INFORMATION_POLICY_FREE_UNITS_PROCESSED: StaticSchema = ( - 7, - n0, - _GSIPFUP, - 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_UNITS_PROCESSED: StaticSchema = ( - 7, - n0, - _GSIPUP, - 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_TOPIC_POLICY_UNITS_PROCESSED: StaticSchema = (7, n0, _GTPUP, 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_WORD_POLICY_UNITS_PROCESSED: StaticSchema = (7, n0, _GWPUP, 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_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), +GUARDRAIL_AUTOMATED_REASONING_LOGIC_WARNING_TYPE = Schema.collection( + id=ShapeID( + "com.amazonaws.bedrockruntime#GuardrailAutomatedReasoningLogicWarningType" ), + shape_type=ShapeType.ENUM, + members={"ALWAYS_FALSE": {"target": UNIT}, "ALWAYS_TRUE": {"target": UNIT}}, ) -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, - ), - ( - (-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), - ), +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_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), +GUARDRAIL_AUTOMATED_REASONING_TRANSLATION_CONFIDENCE = Schema( + id=ShapeID( + "com.amazonaws.bedrockruntime#GuardrailAutomatedReasoningTranslationConfidence" ), + shape_type=ShapeType.DOUBLE, ) -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), +GUARDRAIL_AUTOMATED_REASONING_INPUT_TEXT_REFERENCE = Schema.collection( + id=ShapeID( + "com.amazonaws.bedrockruntime#GuardrailAutomatedReasoningInputTextReference" ), + members={ + "text": { + "target": GUARDRAIL_AUTOMATED_REASONING_STATEMENT_NATURAL_LANGUAGE_CONTENT + } + }, ) -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), +GUARDRAIL_AUTOMATED_REASONING_INPUT_TEXT_REFERENCE_LIST = Schema.collection( + id=ShapeID( + "com.amazonaws.bedrockruntime#GuardrailAutomatedReasoningInputTextReferenceList" ), + 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_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_IMPOSSIBLE_FINDING = Schema.collection( + id=ShapeID( + "com.amazonaws.bedrockruntime#GuardrailAutomatedReasoningImpossibleFinding" ), + members={ + "translation": {"target": GUARDRAIL_AUTOMATED_REASONING_TRANSLATION}, + "contradictingRules": {"target": GUARDRAIL_AUTOMATED_REASONING_RULE_LIST}, + "logicWarning": {"target": GUARDRAIL_AUTOMATED_REASONING_LOGIC_WARNING}, + }, ) -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), +GUARDRAIL_AUTOMATED_REASONING_INVALID_FINDING = Schema.collection( + id=ShapeID( + "com.amazonaws.bedrockruntime#GuardrailAutomatedReasoningInvalidFinding" ), + members={ + "translation": {"target": GUARDRAIL_AUTOMATED_REASONING_TRANSLATION}, + "contradictingRules": {"target": GUARDRAIL_AUTOMATED_REASONING_RULE_LIST}, + "logicWarning": {"target": GUARDRAIL_AUTOMATED_REASONING_LOGIC_WARNING}, + }, ) -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_NO_TRANSLATIONS_FINDING = Schema.collection( + id=ShapeID( + "com.amazonaws.bedrockruntime#GuardrailAutomatedReasoningNoTranslationsFinding" + ) ) -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, +GUARDRAIL_AUTOMATED_REASONING_SCENARIO = Schema.collection( + id=ShapeID("com.amazonaws.bedrockruntime#GuardrailAutomatedReasoningScenario"), + members={"statements": {"target": GUARDRAIL_AUTOMATED_REASONING_STATEMENT_LIST}}, +) + +GUARDRAIL_AUTOMATED_REASONING_SATISFIABLE_FINDING = Schema.collection( + id=ShapeID( + "com.amazonaws.bedrockruntime#GuardrailAutomatedReasoningSatisfiableFinding" ), - ( - (-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={ + "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" + ) +) + +GUARDRAIL_AUTOMATED_REASONING_DIFFERENCE_SCENARIO_LIST = Schema.collection( + id=ShapeID( + "com.amazonaws.bedrockruntime#GuardrailAutomatedReasoningDifferenceScenarioList" ), + shape_type=ShapeType.LIST, + members={"member": {"target": GUARDRAIL_AUTOMATED_REASONING_SCENARIO}}, ) -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), +GUARDRAIL_AUTOMATED_REASONING_TRANSLATION_LIST = Schema.collection( + id=ShapeID( + "com.amazonaws.bedrockruntime#GuardrailAutomatedReasoningTranslationList" ), + shape_type=ShapeType.LIST, + members={"member": {"target": GUARDRAIL_AUTOMATED_REASONING_TRANSLATION}}, ) -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), +GUARDRAIL_AUTOMATED_REASONING_TRANSLATION_OPTION = Schema.collection( + id=ShapeID( + "com.amazonaws.bedrockruntime#GuardrailAutomatedReasoningTranslationOption" ), + members={ + "translations": {"target": GUARDRAIL_AUTOMATED_REASONING_TRANSLATION_LIST} + }, ) -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), +GUARDRAIL_AUTOMATED_REASONING_TRANSLATION_OPTION_LIST = Schema.collection( + id=ShapeID( + "com.amazonaws.bedrockruntime#GuardrailAutomatedReasoningTranslationOptionList" ), + shape_type=ShapeType.LIST, + members={"member": {"target": GUARDRAIL_AUTOMATED_REASONING_TRANSLATION_OPTION}}, ) -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), +GUARDRAIL_AUTOMATED_REASONING_TRANSLATION_AMBIGUOUS_FINDING = Schema.collection( + id=ShapeID( + "com.amazonaws.bedrockruntime#GuardrailAutomatedReasoningTranslationAmbiguousFinding" ), + members={ + "options": {"target": GUARDRAIL_AUTOMATED_REASONING_TRANSLATION_OPTION_LIST}, + "differenceScenarios": { + "target": GUARDRAIL_AUTOMATED_REASONING_DIFFERENCE_SCENARIO_LIST + }, + }, ) -INVOKE_GUARDRAIL_CHECKS_OUTPUT: StaticSchema = ( - 18, - n0, - _IGCO, - {_sSI: _cIGCRo}, - (_res, _u), - ((GUARDRAIL_CHECKS_RESULTS, 1), (GUARDRAIL_CHECKS_USAGE_RESULTS, 1)), +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: StaticOperationSchema = ( - 23, - n0, - _IGC, - { - _smit: MappingProxyType( - {"code": 200, "method": "POST", "uri": "/guardrail-checks/invoke"} - ) +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_INPUT, - INVOKE_GUARDRAIL_CHECKS_OUTPUT, - ( - ACCESS_DENIED_EXCEPTION, - INTERNAL_SERVER_EXCEPTION, - SERVICE_UNAVAILABLE_EXCEPTION, - THROTTLING_EXCEPTION, - VALIDATION_EXCEPTION, - ), ) -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_FINDING_LIST = Schema.collection( + id=ShapeID("com.amazonaws.bedrockruntime#GuardrailAutomatedReasoningFindingList"), + shape_type=ShapeType.LIST, + members={"member": {"target": GUARDRAIL_AUTOMATED_REASONING_FINDING}}, ) -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), +GUARDRAIL_AUTOMATED_REASONING_POLICY_ASSESSMENT = Schema.collection( + id=ShapeID( + "com.amazonaws.bedrockruntime#GuardrailAutomatedReasoningPolicyAssessment" ), + members={"findings": {"target": GUARDRAIL_AUTOMATED_REASONING_FINDING_LIST}}, ) -S3_LOCATION: StaticSchema = (18, n0, _SL, 0, (_ur, _bO), ((S3_URI, 1), (ACCOUNT_ID, 0))) +GUARDRAIL_CONTENT_POLICY_ACTION = Schema.collection( + id=ShapeID("com.amazonaws.bedrockruntime#GuardrailContentPolicyAction"), + shape_type=ShapeType.ENUM, + members={"BLOCKED": {"target": UNIT}, "NONE": {"target": UNIT}}, +) -AUDIO_SOURCE: StaticSchema = (19, n0, _AS, 4, (_b, _sLo), ((1, 0), (S3_LOCATION, 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_BLOCK: StaticSchema = ( - 18, - n0, - _AB, - 0, - (_f, _so, _er), - ((AUDIO_FORMAT, 1), (AUDIO_SOURCE, 1), (ERROR_BLOCK, 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}, + }, ) -CACHE_TTL: StaticSchema = (14, n0, _CTTL, 0, (_FM, _OH), ((-1, 0), (-1, 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_POINT_TYPE: StaticSchema = (14, n0, _CPT, 0, (_DEFAULT,), ((-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_BLOCK: StaticSchema = ( - 18, - n0, - _CPB, - 0, - (_ty, _tt), - ((CACHE_POINT_TYPE, 1), (CACHE_TTL, 0)), +GUARDRAIL_CONTENT_FILTER_LIST = Schema.collection( + id=ShapeID("com.amazonaws.bedrockruntime#GuardrailContentFilterList"), + shape_type=ShapeType.LIST, + members={"member": {"target": GUARDRAIL_CONTENT_FILTER}}, ) -DOCUMENT_CHAR_LOCATION: StaticSchema = ( - 18, - n0, - _DCL, - 0, - (_dI, _star, _en), - ((7, 0), (7, 0), (7, 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_CHUNK_LOCATION: StaticSchema = ( - 18, - n0, - _DCLo, - 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_PAGE_LOCATION: StaticSchema = ( - 18, - n0, - _DPL, - 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}}, ) -SEARCH_RESULT_LOCATION: StaticSchema = ( - 18, - n0, - _SRL, - 0, - (_sRI, _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}}, ) -WEB_LOCATION: StaticSchema = (18, n0, _WL, 0, (_url, _do), ((3, 0), (3, 0))) +IMAGES_GUARDED = Schema( + id=ShapeID("com.amazonaws.bedrockruntime#ImagesGuarded"), + 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), - ), +IMAGES_TOTAL = Schema( + id=ShapeID("com.amazonaws.bedrockruntime#ImagesTotal"), shape_type=ShapeType.INTEGER ) -CITATION_SOURCE_CONTENT: StaticSchema = (19, n0, _CSC, 0, (_te,), ((3, 0),)) +GUARDRAIL_IMAGE_COVERAGE = Schema.collection( + id=ShapeID("com.amazonaws.bedrockruntime#GuardrailImageCoverage"), + members={"guarded": {"target": IMAGES_GUARDED}, "total": {"target": IMAGES_TOTAL}}, +) -CITATION_SOURCE_CONTENT_LIST: StaticSchema = ( - 16, - n0, - _CSCL, - 0, - (_me,), - ((CITATION_SOURCE_CONTENT, 0),), +TEXT_CHARACTERS_GUARDED = Schema( + id=ShapeID("com.amazonaws.bedrockruntime#TextCharactersGuarded"), + 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)), +TEXT_CHARACTERS_TOTAL = Schema( + id=ShapeID("com.amazonaws.bedrockruntime#TextCharactersTotal"), + shape_type=ShapeType.INTEGER, ) -CITATIONS: StaticSchema = (16, n0, _Ci, 0, (_me,), ((CITATION, 0),)) +GUARDRAIL_TEXT_CHARACTERS_COVERAGE = Schema.collection( + id=ShapeID("com.amazonaws.bedrockruntime#GuardrailTextCharactersCoverage"), + members={ + "guarded": {"target": TEXT_CHARACTERS_GUARDED}, + "total": {"target": TEXT_CHARACTERS_TOTAL}, + }, +) -CITATION_GENERATED_CONTENT: StaticSchema = (19, n0, _CGC, 0, (_te,), ((3, 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_LIST: StaticSchema = ( - 16, - n0, - _CGCL, - 0, - (_me,), - ((CITATION_GENERATED_CONTENT, 0),), +GUARDRAIL_PROCESSING_LATENCY = Schema( + id=ShapeID("com.amazonaws.bedrockruntime#GuardrailProcessingLatency"), + shape_type=ShapeType.LONG, ) -CITATIONS_CONTENT_BLOCK: StaticSchema = ( - 18, - n0, - _CCB, - 0, - (_co, _ci), - ((CITATION_GENERATED_CONTENT_LIST, 0), (CITATIONS, 0)), +GUARDRAIL_AUTOMATED_REASONING_POLICIES_PROCESSED = Schema( + id=ShapeID( + "com.amazonaws.bedrockruntime#GuardrailAutomatedReasoningPoliciesProcessed" + ), + shape_type=ShapeType.INTEGER, ) -CITATIONS_CONFIG: StaticSchema = (18, n0, _CC, 0, (_ena,), ((2, 1),)) +GUARDRAIL_AUTOMATED_REASONING_POLICY_UNITS_PROCESSED = Schema( + id=ShapeID( + "com.amazonaws.bedrockruntime#GuardrailAutomatedReasoningPolicyUnitsProcessed" + ), + 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_IMAGE_UNITS_PROCESSED = Schema( + id=ShapeID( + "com.amazonaws.bedrockruntime#GuardrailContentPolicyImageUnitsProcessed" + ), + shape_type=ShapeType.INTEGER, ) -DOCUMENT_CONTENT_BLOCK: StaticSchema = (19, n0, _DCB, 0, (_te,), ((3, 0),)) +GUARDRAIL_CONTENT_POLICY_UNITS_PROCESSED = Schema( + id=ShapeID("com.amazonaws.bedrockruntime#GuardrailContentPolicyUnitsProcessed"), + shape_type=ShapeType.INTEGER, +) -DOCUMENT_CONTENT_BLOCKS: StaticSchema = ( - 16, - n0, - _DCBo, - 0, - (_me,), - ((DOCUMENT_CONTENT_BLOCK, 0),), +GUARDRAIL_CONTEXTUAL_GROUNDING_POLICY_UNITS_PROCESSED = Schema( + id=ShapeID( + "com.amazonaws.bedrockruntime#GuardrailContextualGroundingPolicyUnitsProcessed" + ), + 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_FREE_UNITS_PROCESSED = Schema( + id=ShapeID( + "com.amazonaws.bedrockruntime#GuardrailSensitiveInformationPolicyFreeUnitsProcessed" + ), + shape_type=ShapeType.INTEGER, ) -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), +GUARDRAIL_SENSITIVE_INFORMATION_POLICY_UNITS_PROCESSED = Schema( + id=ShapeID( + "com.amazonaws.bedrockruntime#GuardrailSensitiveInformationPolicyUnitsProcessed" ), + 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_CONVERSE_IMAGE_FORMAT: StaticSchema = ( - 14, - n0, - _GCIF, - 0, - (_PNG, _JPEG), - ((-1, 0), (-1, 0)), +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_SOURCE: StaticSchema = (19, n0, _GCIS, 4, (_b,), ((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_BLOCK: StaticSchema = ( - 18, - n0, - _GCIB, - 4, - (_f, _so), - ((GUARDRAIL_CONVERSE_IMAGE_FORMAT, 1), (GUARDRAIL_CONVERSE_IMAGE_SOURCE, 1)), +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_CONTENT_QUALIFIER: StaticSchema = ( - 14, - n0, - _GCCQ, - 0, - (_GS, _QUERY, _GC), - ((-1, 0), (-1, 0), (-1, 0)), +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_LIST: StaticSchema = ( - 16, - n0, - _GCCQL, - 0, - (_me,), - ((GUARDRAIL_CONVERSE_CONTENT_QUALIFIER, 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_TEXT_BLOCK: StaticSchema = ( - 18, - n0, - _GCTB, - 0, - (_te, _q), - ((3, 1), (GUARDRAIL_CONVERSE_CONTENT_QUALIFIER_LIST, 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_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_REGEX_FILTER_LIST = Schema.collection( + id=ShapeID("com.amazonaws.bedrockruntime#GuardrailRegexFilterList"), + shape_type=ShapeType.LIST, + members={"member": {"target": GUARDRAIL_REGEX_FILTER}}, ) -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), +GUARDRAIL_SENSITIVE_INFORMATION_POLICY_ASSESSMENT = Schema.collection( + id=ShapeID( + "com.amazonaws.bedrockruntime#GuardrailSensitiveInformationPolicyAssessment" ), + 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"))], + }, + }, ) -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_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}, + }, ) -CONTENT_BLOCKS: StaticSchema = (16, n0, _CBo, 0, (_me,), ((CONTENT_BLOCK, 0),)) +GUARDRAIL_TOPIC_LIST = Schema.collection( + id=ShapeID("com.amazonaws.bedrockruntime#GuardrailTopicList"), + shape_type=ShapeType.LIST, + members={"member": {"target": GUARDRAIL_TOPIC}}, +) -CONVERSATION_ROLE: StaticSchema = ( - 14, - n0, - _CR, - 0, - (_USER, _ASSISTANT, _SYSTEM), - ((-1, 0), (-1, 0), (-1, 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"))], + } + }, ) -MESSAGE: StaticSchema = ( - 18, - n0, - _M, - 0, - (_ro, _co), - ((CONVERSATION_ROLE, 1), (CONTENT_BLOCKS, 1)), +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}, + }, ) -MESSAGES: StaticSchema = (16, n0, _Me, 0, (_me,), ((MESSAGE, 0),)) +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}, + }, +) -CONVERSATIONAL_MODEL_ID: StaticSchema = (3, n0, _CMI, 0) +GUARDRAIL_MANAGED_WORD_LIST = Schema.collection( + id=ShapeID("com.amazonaws.bedrockruntime#GuardrailManagedWordList"), + shape_type=ShapeType.LIST, + members={"member": {"target": GUARDRAIL_MANAGED_WORD}}, +) -JSON_SCHEMA_DEFINITION: StaticSchema = ( - 18, - n0, - _JSD, - 0, - (_sch, _n, _de), - ((3, 1), (3, 0), (3, 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"))], + }, + }, ) -OUTPUT_FORMAT_STRUCTURE: StaticSchema = ( - 19, - n0, - _OFS, - 4, - (_jS,), - ((JSON_SCHEMA_DEFINITION, 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_TYPE: StaticSchema = (14, n0, _OFT, 0, (_JS,), ((-1, 0),)) +GUARDRAIL_ASSESSMENT_LIST = Schema.collection( + id=ShapeID("com.amazonaws.bedrockruntime#GuardrailAssessmentList"), + shape_type=ShapeType.LIST, + members={"member": {"target": GUARDRAIL_ASSESSMENT}}, +) -OUTPUT_FORMAT: StaticSchema = ( - 18, - n0, - _OF, - 0, - (_ty, _str), - ((OUTPUT_FORMAT_TYPE, 1), (OUTPUT_FORMAT_STRUCTURE, 1)), +GUARDRAIL_OUTPUT_TEXT = Schema( + id=ShapeID("com.amazonaws.bedrockruntime#GuardrailOutputText"), + shape_type=ShapeType.STRING, ) -OUTPUT_CONFIG: StaticSchema = (18, n0, _OC, 0, (_tF, _ef), ((OUTPUT_FORMAT, 0), (3, 0))) +GUARDRAIL_OUTPUT_CONTENT = Schema.collection( + id=ShapeID("com.amazonaws.bedrockruntime#GuardrailOutputContent"), + members={"text": {"target": GUARDRAIL_OUTPUT_TEXT}}, +) -PERFORMANCE_CONFIG_LATENCY: StaticSchema = ( - 14, - n0, - _PCL, - 0, - (_STANDARD, _OPTIMIZED), - ((-1, 0), (-1, 0)), +GUARDRAIL_OUTPUT_CONTENT_LIST = Schema.collection( + id=ShapeID("com.amazonaws.bedrockruntime#GuardrailOutputContentList"), + shape_type=ShapeType.LIST, + members={"member": {"target": GUARDRAIL_OUTPUT_CONTENT}}, ) -PERFORMANCE_CONFIGURATION: StaticSchema = ( - 18, - n0, - _PC, - 0, - (_la,), - ((PERFORMANCE_CONFIG_LATENCY, {_smith: _stan}),), +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}, + }, ) -PROMPT_VARIABLE_VALUES: StaticSchema = (19, n0, _PVV, 0, (_te,), ((3, 0),)) +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_MAP: StaticSchema = ( - 17, - n0, - _PVM, - 4, - (_k, _v), - ((3, 0), (PROMPT_VARIABLE_VALUES, 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"))], + } + }, ) -REQUEST_METADATA: StaticSchema = (17, n0, _RM, 4, (_k, _v), ((3, 0), (3, 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}}, +) -SERVICE_TIER_TYPE: StaticSchema = ( - 14, - n0, - _STT, - 0, - (_PRIORITY, _DEFAULT, _FLEX, _RESERVED), - ((-1, 0), (-1, 0), (-1, 0), (-1, 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: StaticSchema = (18, n0, _STe, 0, (_ty,), ((SERVICE_TIER_TYPE, 1),)) +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}, + }, +) -SYSTEM_CONTENT_BLOCK: StaticSchema = ( - 19, - n0, - _SCB, - 0, - (_te, _gCu, _cPa), - ( - (NON_EMPTY_STRING, 0), - (GUARDRAIL_CONVERSE_CONTENT_BLOCK, 0), - (CACHE_POINT_BLOCK, 0), +GUARDRAIL_CHECKS_PROMPT_ATTACK_CATEGORY_CONFIG = Schema.collection( + id=ShapeID( + "com.amazonaws.bedrockruntime#GuardrailChecksPromptAttackCategoryConfig" ), + members={ + "category": { + "target": GUARDRAIL_CHECKS_PROMPT_ATTACK_CATEGORY, + "traits": [Trait.new(id=ShapeID("smithy.api#required"))], + } + }, ) -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), +GUARDRAIL_CHECKS_PROMPT_ATTACK_CATEGORY_CONFIG_LIST = Schema.collection( + id=ShapeID( + "com.amazonaws.bedrockruntime#GuardrailChecksPromptAttackCategoryConfigList" ), + shape_type=ShapeType.LIST, + members={"member": {"target": GUARDRAIL_CHECKS_PROMPT_ATTACK_CATEGORY_CONFIG}}, ) -CONVERSE_METRICS: StaticSchema = (18, n0, _CM, 0, (_lM,), ((8, 1),)) +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_OUTPUT: StaticSchema = (19, n0, _CO, 0, (_m,), ((MESSAGE, 0),)) +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}, + }, +) -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 = 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"))], + } + }, ) -GUARDRAIL_ASSESSMENT_MAP: StaticSchema = ( - 17, - n0, - _GAM, - 0, - (_k, _v), - ((3, 0), (GUARDRAIL_ASSESSMENT, 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} + }, ) -MODEL_OUTPUTS: StaticSchema = (16, n0, _MO, 0, (_me,), ((GUARDRAIL_OUTPUT_TEXT, 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"))], + } + }, +) -GUARDRAIL_ASSESSMENT_LIST_MAP: StaticSchema = ( - 17, - n0, - _GALM, - 0, - (_k, _v), - ((3, 0), (GUARDRAIL_ASSESSMENT_LIST, 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_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_TEXT_CONTENT = Schema( + id=ShapeID("com.amazonaws.bedrockruntime#GuardrailChecksTextContent"), + shape_type=ShapeType.STRING, + traits=[Trait.new(id=ShapeID("smithy.api#sensitive"))], ) -INVOKED_MODEL_ID: StaticSchema = (3, n0, _IMI, 0) +GUARDRAIL_CHECKS_CONTENT_BLOCK = Schema.collection( + id=ShapeID("com.amazonaws.bedrockruntime#GuardrailChecksContentBlock"), + shape_type=ShapeType.UNION, + members={"text": {"target": GUARDRAIL_CHECKS_TEXT_CONTENT}}, +) -PROMPT_ROUTER_TRACE: StaticSchema = (18, n0, _PRT, 0, (_iMI,), ((INVOKED_MODEL_ID, 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}}, +) -CONVERSE_TRACE: StaticSchema = ( - 18, - n0, - _CT, - 0, - (_gu, _pR), - ((GUARDRAIL_TRACE_ASSESSMENT, 0), (PROMPT_ROUTER_TRACE, 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}, + }, ) -CACHE_DETAIL: StaticSchema = (18, n0, _CD, 0, (_tt, _iT), ((CACHE_TTL, 1), (7, 1))) +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_DETAILS_LIST: StaticSchema = (16, n0, _CDL, 0, (_me,), ((CACHE_DETAIL, 0),)) +GUARDRAIL_CHECKS_MESSAGE_LIST = Schema.collection( + id=ShapeID("com.amazonaws.bedrockruntime#GuardrailChecksMessageList"), + shape_type=ShapeType.LIST, + members={"member": {"target": GUARDRAIL_CHECKS_MESSAGE}}, +) -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)), +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"))], + }, + }, ) -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_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"))], + }, + }, ) -STATUS_CODE: StaticSchema = (7, n0, _SCt, 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}}, +) -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_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_NOT_READY_EXCEPTION: StaticSchema = ( - 18, - n0, - _MNRE, - {_s: _c, _sE: 429}, - (_m,), - ((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_TIMEOUT_EXCEPTION: StaticSchema = ( - 18, - n0, - _MTE, - {_s: _c, _sE: 408}, - (_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}}, ) -CONVERSE: StaticOperationSchema = ( - 23, - n0, - _Co, - { - _smit: MappingProxyType( - {"code": 200, "method": "POST", "uri": "/model/{modelId}/converse"} - ) +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_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, - ), ) -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}), +GUARDRAIL_CHECKS_SENSITIVE_INFORMATION_RESULT_ENTRY = Schema.collection( + id=ShapeID( + "com.amazonaws.bedrockruntime#GuardrailChecksSensitiveInformationResultEntry" ), + 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"))], + }, + }, ) -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), +GUARDRAIL_CHECKS_SENSITIVE_INFORMATION_RESULT_LIST = Schema.collection( + id=ShapeID( + "com.amazonaws.bedrockruntime#GuardrailChecksSensitiveInformationResultList" ), + shape_type=ShapeType.LIST, + members={"member": {"target": GUARDRAIL_CHECKS_SENSITIVE_INFORMATION_RESULT_ENTRY}}, ) -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_RESULT = Schema.collection( + id=ShapeID( + "com.amazonaws.bedrockruntime#GuardrailChecksSensitiveInformationResult" ), + members={ + "results": { + "target": GUARDRAIL_CHECKS_SENSITIVE_INFORMATION_RESULT_LIST, + "traits": [Trait.new(id=ShapeID("smithy.api#required"))], + }, + "truncated": {"target": BOOLEAN}, + }, ) -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_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 + }, + }, ) -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), - ), +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"))], + } + }, ) -CONVERSE_STREAM_OPERATION_OUTPUT: StaticSchema = ( - 18, - n0, - _CSOO, - {_sSI: _cCSRo}, - (_stre,), - ((CONVERSE_STREAM_OUTPUT, 16),), +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"))], + } + }, ) -CONVERSE_STREAM: StaticOperationSchema = ( - 23, - n0, - _CS, - { - _smit: MappingProxyType( - {"code": 200, "method": "POST", "uri": "/model/{modelId}/converse-stream"} - ) +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"))], + } }, - 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, - ), ) -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}), - ), +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 + }, + }, ) -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}), - ), +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"))], + }, + }, ) -INVOKE_MODEL: StaticOperationSchema = ( - 23, - n0, - _IM, - { - _smit: MappingProxyType( - {"code": 200, "method": "POST", "uri": "/model/{modelId}/invoke"} +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"} + ), ) + ], +) + +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}, }, - 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, - ), ) -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), - ), +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")], + }, + }, ) -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", - } - ) +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}, }, - 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, - ), ) -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}), - ), +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}, + }, ) -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), - ), +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}, + }, ) -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}), - ), +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}, + }, ) -INVOKE_MODEL_WITH_RESPONSE_STREAM: StaticOperationSchema = ( - 23, - n0, - _IMWRS, - { - _smit: MappingProxyType( - { - "code": 200, - "method": "POST", - "uri": "/model/{modelId}/invoke-with-response-stream", - } - ) +CACHE_TTL = Schema.collection( + id=ShapeID("com.amazonaws.bedrockruntime#CacheTTL"), + shape_type=ShapeType.ENUM, + members={"FIVE_MINUTES": {"target": UNIT}, "ONE_HOUR": {"target": UNIT}}, +) + +CACHE_POINT_TYPE = Schema.collection( + id=ShapeID("com.amazonaws.bedrockruntime#CachePointType"), + shape_type=ShapeType.ENUM, + members={"DEFAULT": {"target": UNIT}}, +) + +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_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, - ), ) -CONVERSE_TOKENS_REQUEST: StaticSchema = ( - 18, - n0, - _CTR, - 0, - (_mes, _sy, _tCoo, _aMRF), - ((MESSAGES, 0), (SYSTEM_CONTENT_BLOCKS, 0), (TOOL_CONFIGURATION, 0), (13, 0)), +DOCUMENT_CHAR_LOCATION = Schema.collection( + id=ShapeID("com.amazonaws.bedrockruntime#DocumentCharLocation"), + members={ + "documentIndex": {"target": INTEGER}, + "start": {"target": INTEGER}, + "end": {"target": INTEGER}, + }, +) + +DOCUMENT_CHUNK_LOCATION = Schema.collection( + id=ShapeID("com.amazonaws.bedrockruntime#DocumentChunkLocation"), + members={ + "documentIndex": {"target": INTEGER}, + "start": {"target": INTEGER}, + "end": {"target": INTEGER}, + }, ) -INVOKE_MODEL_TOKENS_REQUEST: StaticSchema = (18, n0, _IMTR, 0, (_bo,), ((BODY, 1),)) +DOCUMENT_PAGE_LOCATION = Schema.collection( + id=ShapeID("com.amazonaws.bedrockruntime#DocumentPageLocation"), + members={ + "documentIndex": {"target": INTEGER}, + "start": {"target": INTEGER}, + "end": {"target": INTEGER}, + }, +) + +SEARCH_RESULT_LOCATION = Schema.collection( + id=ShapeID("com.amazonaws.bedrockruntime#SearchResultLocation"), + members={ + "searchResultIndex": {"target": INTEGER}, + "start": {"target": INTEGER}, + "end": {"target": INTEGER}, + }, +) -COUNT_TOKENS_INPUT: StaticSchema = ( - 19, - n0, - _CTI, - 0, - (_iMn, _conv), - ((INVOKE_MODEL_TOKENS_REQUEST, 0), (CONVERSE_TOKENS_REQUEST, 0)), +WEB_LOCATION = Schema.collection( + id=ShapeID("com.amazonaws.bedrockruntime#WebLocation"), + members={"url": {"target": STRING}, "domain": {"target": STRING}}, ) -FOUNDATION_MODEL_VERSION_IDENTIFIER: StaticSchema = (3, n0, _FMVI, 0) +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}, + }, +) -COUNT_TOKENS_OPERATION_INPUT: StaticSchema = ( - 18, - n0, - _CTOI, - {_sSI: _cCTR}, - (_mI, _inp), - ((FOUNDATION_MODEL_VERSION_IDENTIFIER, 9), (COUNT_TOKENS_INPUT, 1)), +CITATION_SOURCE_CONTENT = Schema.collection( + id=ShapeID("com.amazonaws.bedrockruntime#CitationSourceContent"), + shape_type=ShapeType.UNION, + members={"text": {"target": STRING}}, ) -COUNT_TOKENS_OUTPUT: StaticSchema = (18, n0, _CTO, {_sSI: _cCTRo}, (_iT,), ((7, 1),)) +CITATION_SOURCE_CONTENT_LIST = Schema.collection( + id=ShapeID("com.amazonaws.bedrockruntime#CitationSourceContentList"), + shape_type=ShapeType.LIST, + members={"member": {"target": CITATION_SOURCE_CONTENT}}, +) -COUNT_TOKENS: StaticOperationSchema = ( - 23, - n0, - _CTo, - { - _smit: MappingProxyType( - {"code": 200, "method": "POST", "uri": "/model/{modelId}/count-tokens"} - ) +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_OPERATION_INPUT, - COUNT_TOKENS_OUTPUT, - ( - ACCESS_DENIED_EXCEPTION, - INTERNAL_SERVER_EXCEPTION, - RESOURCE_NOT_FOUND_EXCEPTION, - SERVICE_UNAVAILABLE_EXCEPTION, - THROTTLING_EXCEPTION, - VALIDATION_EXCEPTION, - ), ) -AMAZON_BEDROCK_FRONTEND_SERVICE: StaticSchema = ( - 21, - n0, - _ABFS, - { - _aw: MappingProxyType({"name": "bedrock"}), - _sBm: 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", - } - ), - } +CITATIONS = Schema.collection( + id=ShapeID("com.amazonaws.bedrockruntime#Citations"), + shape_type=ShapeType.LIST, + members={"member": {"target": CITATION}}, +) + +CITATION_GENERATED_CONTENT = Schema.collection( + id=ShapeID("com.amazonaws.bedrockruntime#CitationGeneratedContent"), + shape_type=ShapeType.UNION, + members={"text": {"target": STRING}}, +) + +CITATION_GENERATED_CONTENT_LIST = Schema.collection( + id=ShapeID("com.amazonaws.bedrockruntime#CitationGeneratedContentList"), + shape_type=ShapeType.LIST, + members={"member": {"target": CITATION_GENERATED_CONTENT}}, +) + +CITATIONS_CONTENT_BLOCK = Schema.collection( + id=ShapeID("com.amazonaws.bedrockruntime#CitationsContentBlock"), + members={ + "content": {"target": CITATION_GENERATED_CONTENT_LIST}, + "citations": {"target": CITATIONS}, + }, +) + +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", ), - "conditions": ( - MappingProxyType( - { - "fn": "isSet", - "argv": (MappingProxyType({"ref": "Endpoint"}),), - } - ), - 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( - { - "fn": "getAttr", - "argv": ( - MappingProxyType( - {"ref": "PartitionResult"} - ), - "supportsDualStack", - ), - } - ), - True, - ), - } - ), - MappingProxyType( - { - "fn": "booleanEquals", - "argv": ( - MappingProxyType( - { - "fn": "getAttr", - "argv": ( - MappingProxyType( - {"ref": "PartitionResult"} - ), - "supportsFIPS", - ), - } - ), - True, - ), - } - ), + ], + }, + "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", ), - "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( + ], + }, + "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( { - "conditions": (), - "endpoint": MappingProxyType( + "Region": MappingProxyType( { - "url": MappingProxyType({"ref": "Endpoint"}), - "properties": MappingProxyType[str, object]({}), - "headers": MappingProxyType[str, object]({}), + "builtIn": "AWS::Region", + "required": False, + "documentation": "The AWS region used to dispatch the request.", + "type": "string", } ), - "type": "endpoint", - } - ), - MappingProxyType( - { - "conditions": (), - "endpoint": MappingProxyType( + "UseDualStack": MappingProxyType( { - "url": "https://bedrock-runtime-fips.{Region}.{PartitionResult#dualStackDnsSuffix}", - "properties": MappingProxyType[str, object]({}), - "headers": MappingProxyType[str, object]({}), + "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", } ), - "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( + "UseFIPS": MappingProxyType( { - "url": "https://bedrock-runtime-fips.{Region}.{PartitionResult#dnsSuffix}", - "properties": MappingProxyType[str, object]({}), - "headers": MappingProxyType[str, object]({}), + "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", } ), - "type": "endpoint", - } - ), - MappingProxyType( - { - "conditions": (), - "error": "FIPS is enabled but this partition does not support FIPS", - "type": "error", - } - ), - MappingProxyType( - { - "conditions": (), - "endpoint": MappingProxyType( + "Endpoint": MappingProxyType( { - "url": "https://bedrock-runtime.{Region}.{PartitionResult#dualStackDnsSuffix}", - "properties": MappingProxyType[str, object]({}), - "headers": MappingProxyType[str, object]({}), + "builtIn": "SDK::Endpoint", + "required": False, + "documentation": "Override the endpoint used to send this request", + "type": "string", } ), - "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", - } + "conditions": ( + MappingProxyType( + { + "fn": "isSet", + "argv": (MappingProxyType({"ref": "Endpoint"}),), + } + ), + 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( + { + "fn": "getAttr", + "argv": ( + MappingProxyType( + {"ref": "PartitionResult"} + ), + "supportsDualStack", + ), + } + ), + True, + ), + } + ), + MappingProxyType( + { + "fn": "booleanEquals", + "argv": ( + MappingProxyType( + { + "fn": "getAttr", + "argv": ( + MappingProxyType( + {"ref": "PartitionResult"} + ), + "supportsFIPS", + ), + } + ), + True, + ), + } + ), ), - MappingProxyType( - { - "conditions": (), - "error": "Invalid Configuration: Missing Region", - "type": "error", - } + "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( + { + "url": "https://bedrock-runtime.{Region}.{PartitionResult#dualStackDnsSuffix}", + "properties": MappingProxyType({}), + "headers": MappingProxyType({}), + } + ), + "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({}), + "headers": MappingProxyType({}), + } + ), + "type": "endpoint", + } + ), + MappingProxyType( + { + "conditions": (), + "error": "Invalid Configuration: Missing Region", + "type": "error", + } + ), ), - ), - "root": 2, - "nodeCount": 13, - "nodes": "/////wAAAAH/////AAAAAAAAAAwAAAADAAAAAQAAAAQF9eELAAAAAgAAAAUF9eELAAAAAwAAAAgAAAAGAAAABAAAAAcF9eEKAAAABQX14QgF9eEJAAAABAAAAAoAAAAJAAAABgX14QYF9eEHAAAABQAAAAsF9eEFAAAABgX14QQF9eEFAAAAAwX14QEAAAANAAAABAX14QIF9eED", - } + "root": 2, + "nodeCount": 13, + "nodes": "/////wAAAAH/////AAAAAAAAAAwAAAADAAAAAQAAAAQF9eELAAAAAgAAAAUF9eELAAAAAwAAAAgAAAAGAAAABAAAAAcF9eEKAAAABQX14QgF9eEJAAAABAAAAAoAAAAJAAAABgX14QYF9eEHAAAABQAAAAsF9eEFAAAABgX14QQF9eEFAAAAAwX14QEAAAANAAAABAX14QIF9eED", + } + ), ), - _aws: MappingProxyType( - { - "sdkId": "Bedrock Runtime", - "endpointPrefix": "bedrock-runtime", - "cloudTrailEventSource": "bedrock.amazonaws.com", - } + Trait.new( + id=ShapeID("aws.api#service"), + value=MappingProxyType( + { + "sdkId": "Bedrock Runtime", + "endpointPrefix": "bedrock-runtime", + "cloudTrailEventSource": "bedrock.amazonaws.com", + } + ), ), - _aJ: MappingProxyType( - {"http": ("h2", "http/1.1"), "eventStreamHttp": ("h2", "http/1.1")} + Trait.new( + id=ShapeID("aws.protocols#restJson1"), + value=MappingProxyType( + {"http": ("h2", "http/1.1"), "eventStreamHttp": ("h2", "http/1.1")} + ), ), - _sBA: None, - }, + Trait.new(id=ShapeID("smithy.api#httpBearerAuth")), + ], ) 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 c3ebd68a..03cb9490 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,7 +6,6 @@ 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 @@ -248,12 +247,13 @@ class AccessDeniedException(ServiceError): fault: Literal["client", "server"] | None = "client" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_ACCESS_DENIED_EXCEPTION), self) + serializer.write_struct(_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(members[0], self.message) + serializer.write_string( + _SCHEMA_ACCESS_DENIED_EXCEPTION.members["message"], 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(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: - kwargs["message"] = de.read_string(members[0]) + kwargs["message"] = de.read_string( + _SCHEMA_ACCESS_DENIED_EXCEPTION.members["message"] + ) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct(_SCHEMA_ACCESS_DENIED_EXCEPTION, consumer=_consumer) return kwargs def _serialize_additional_model_response_field_paths( serializer: ShapeSerializer, schema: Schema, value: list[str] ) -> None: - member_schema = schema.members_by_index[0] + member_schema = schema.members["member"] 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_by_index[0] + member_schema = schema.members["member"] def _read_value(d: ShapeDeserializer): if d.is_null(): @@ -311,12 +311,14 @@ class GetAsyncInvokeInput: """The invocation's ARN.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_GET_ASYNC_INVOKE_INPUT), self) + serializer.write_struct(_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(members[0], self.invocation_arn) + serializer.write_string( + _SCHEMA_GET_ASYNC_INVOKE_INPUT.members["invocationArn"], + self.invocation_arn, + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -325,18 +327,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(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: - kwargs["invocation_arn"] = de.read_string(members[0]) + kwargs["invocation_arn"] = de.read_string( + _SCHEMA_GET_ASYNC_INVOKE_INPUT.members["invocationArn"] + ) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct(_SCHEMA_GET_ASYNC_INVOKE_INPUT, consumer=_consumer) return kwargs @@ -357,18 +359,23 @@ class AsyncInvokeS3OutputDataConfig: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct( - hydrate(_SCHEMA_ASYNC_INVOKE_S3_OUTPUT_DATA_CONFIG), self - ) + serializer.write_struct(_SCHEMA_ASYNC_INVOKE_S3_OUTPUT_DATA_CONFIG, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_ASYNC_INVOKE_S3_OUTPUT_DATA_CONFIG).members_by_index - serializer.write_string(members[0], self.s3_uri) + serializer.write_string( + _SCHEMA_ASYNC_INVOKE_S3_OUTPUT_DATA_CONFIG.members["s3Uri"], self.s3_uri + ) if self.kms_key_id is not None: - serializer.write_string(members[1], self.kms_key_id) + serializer.write_string( + _SCHEMA_ASYNC_INVOKE_S3_OUTPUT_DATA_CONFIG.members["kmsKeyId"], + self.kms_key_id, + ) if self.bucket_owner is not None: - serializer.write_string(members[2], self.bucket_owner) + serializer.write_string( + _SCHEMA_ASYNC_INVOKE_S3_OUTPUT_DATA_CONFIG.members["bucketOwner"], + self.bucket_owner, + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -377,24 +384,32 @@ 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(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: - kwargs["s3_uri"] = de.read_string(members[0]) + kwargs["s3_uri"] = de.read_string( + _SCHEMA_ASYNC_INVOKE_S3_OUTPUT_DATA_CONFIG.members["s3Uri"] + ) case 1: - kwargs["kms_key_id"] = de.read_string(members[1]) + kwargs["kms_key_id"] = de.read_string( + _SCHEMA_ASYNC_INVOKE_S3_OUTPUT_DATA_CONFIG.members["kmsKeyId"] + ) case 2: - kwargs["bucket_owner"] = de.read_string(members[2]) + kwargs["bucket_owner"] = de.read_string( + _SCHEMA_ASYNC_INVOKE_S3_OUTPUT_DATA_CONFIG.members[ + "bucketOwner" + ] + ) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct( + _SCHEMA_ASYNC_INVOKE_S3_OUTPUT_DATA_CONFIG, consumer=_consumer + ) if "s3_uri" not in kwargs: kwargs["s3_uri"] = "" return kwargs @@ -407,11 +422,13 @@ class AsyncInvokeOutputDataConfigS3OutputDataConfig: value: AsyncInvokeS3OutputDataConfig def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_ASYNC_INVOKE_OUTPUT_DATA_CONFIG), self) + serializer.write_struct(_SCHEMA_ASYNC_INVOKE_OUTPUT_DATA_CONFIG, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_ASYNC_INVOKE_OUTPUT_DATA_CONFIG).members_by_index - serializer.write_struct(members[0], self.value) + serializer.write_struct( + _SCHEMA_ASYNC_INVOKE_OUTPUT_DATA_CONFIG.members["s3OutputDataConfig"], + self.value, + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -456,7 +473,7 @@ def deserialize( ) -> AsyncInvokeOutputDataConfig: self._result = None deserializer.read_struct( - hydrate(_SCHEMA_ASYNC_INVOKE_OUTPUT_DATA_CONFIG), self._consumer + _SCHEMA_ASYNC_INVOKE_OUTPUT_DATA_CONFIG, self._consumer ) if self._result is None: @@ -534,27 +551,49 @@ class GetAsyncInvokeOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_GET_ASYNC_INVOKE_OUTPUT), self) + serializer.write_struct(_SCHEMA_GET_ASYNC_INVOKE_OUTPUT, self) def serialize_members(self, serializer: ShapeSerializer): - 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) + 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 + ) if self.client_request_token is not None: - serializer.write_string(members[2], self.client_request_token) + serializer.write_string( + _SCHEMA_GET_ASYNC_INVOKE_OUTPUT.members["clientRequestToken"], + self.client_request_token, + ) - serializer.write_string(members[3], self.status) + serializer.write_string( + _SCHEMA_GET_ASYNC_INVOKE_OUTPUT.members["status"], self.status + ) if self.failure_message is not None: - serializer.write_string(members[4], self.failure_message) + serializer.write_string( + _SCHEMA_GET_ASYNC_INVOKE_OUTPUT.members["failureMessage"], + self.failure_message, + ) - serializer.write_timestamp(members[5], self.submit_time) + serializer.write_timestamp( + _SCHEMA_GET_ASYNC_INVOKE_OUTPUT.members["submitTime"], self.submit_time + ) if self.last_modified_time is not None: - serializer.write_timestamp(members[6], self.last_modified_time) + serializer.write_timestamp( + _SCHEMA_GET_ASYNC_INVOKE_OUTPUT.members["lastModifiedTime"], + self.last_modified_time, + ) if self.end_time is not None: - serializer.write_timestamp(members[7], self.end_time) + serializer.write_timestamp( + _SCHEMA_GET_ASYNC_INVOKE_OUTPUT.members["endTime"], self.end_time + ) - serializer.write_struct(members[8], self.output_data_config) + serializer.write_struct( + _SCHEMA_GET_ASYNC_INVOKE_OUTPUT.members["outputDataConfig"], + self.output_data_config, + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -563,34 +602,50 @@ 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(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: - kwargs["invocation_arn"] = de.read_string(members[0]) + kwargs["invocation_arn"] = de.read_string( + _SCHEMA_GET_ASYNC_INVOKE_OUTPUT.members["invocationArn"] + ) case 1: - kwargs["model_arn"] = de.read_string(members[1]) + kwargs["model_arn"] = de.read_string( + _SCHEMA_GET_ASYNC_INVOKE_OUTPUT.members["modelArn"] + ) case 2: - kwargs["client_request_token"] = de.read_string(members[2]) + kwargs["client_request_token"] = de.read_string( + _SCHEMA_GET_ASYNC_INVOKE_OUTPUT.members["clientRequestToken"] + ) case 3: - kwargs["status"] = AsyncInvokeStatus(de.read_string(members[3])) + kwargs["status"] = AsyncInvokeStatus( + de.read_string( + _SCHEMA_GET_ASYNC_INVOKE_OUTPUT.members["status"] + ) + ) case 4: - kwargs["failure_message"] = de.read_string(members[4]) + kwargs["failure_message"] = de.read_string( + _SCHEMA_GET_ASYNC_INVOKE_OUTPUT.members["failureMessage"] + ) case 5: - kwargs["submit_time"] = de.read_timestamp(members[5]) + kwargs["submit_time"] = de.read_timestamp( + _SCHEMA_GET_ASYNC_INVOKE_OUTPUT.members["submitTime"] + ) case 6: - kwargs["last_modified_time"] = de.read_timestamp(members[6]) + kwargs["last_modified_time"] = de.read_timestamp( + _SCHEMA_GET_ASYNC_INVOKE_OUTPUT.members["lastModifiedTime"] + ) case 7: - kwargs["end_time"] = de.read_timestamp(members[7]) + kwargs["end_time"] = de.read_timestamp( + _SCHEMA_GET_ASYNC_INVOKE_OUTPUT.members["endTime"] + ) case 8: kwargs["output_data_config"] = ( @@ -598,9 +653,9 @@ def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: ) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct(_SCHEMA_GET_ASYNC_INVOKE_OUTPUT, consumer=_consumer) if "invocation_arn" not in kwargs: kwargs["invocation_arn"] = "" if "model_arn" not in kwargs: @@ -625,12 +680,13 @@ class InternalServerException(ServiceError): fault: Literal["client", "server"] | None = "server" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_INTERNAL_SERVER_EXCEPTION), self) + serializer.write_struct(_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(members[0], self.message) + serializer.write_string( + _SCHEMA_INTERNAL_SERVER_EXCEPTION.members["message"], self.message + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -639,18 +695,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(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: - kwargs["message"] = de.read_string(members[0]) + kwargs["message"] = de.read_string( + _SCHEMA_INTERNAL_SERVER_EXCEPTION.members["message"] + ) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct(_SCHEMA_INTERNAL_SERVER_EXCEPTION, consumer=_consumer) return kwargs @@ -666,12 +722,13 @@ class ThrottlingException(ServiceError): fault: Literal["client", "server"] | None = "client" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_THROTTLING_EXCEPTION), self) + serializer.write_struct(_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(members[0], self.message) + serializer.write_string( + _SCHEMA_THROTTLING_EXCEPTION.members["message"], self.message + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -680,18 +737,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(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: - kwargs["message"] = de.read_string(members[0]) + kwargs["message"] = de.read_string( + _SCHEMA_THROTTLING_EXCEPTION.members["message"] + ) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct(_SCHEMA_THROTTLING_EXCEPTION, consumer=_consumer) return kwargs @@ -707,12 +764,13 @@ class ValidationException(ServiceError): fault: Literal["client", "server"] | None = "client" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_VALIDATION_EXCEPTION), self) + serializer.write_struct(_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(members[0], self.message) + serializer.write_string( + _SCHEMA_VALIDATION_EXCEPTION.members["message"], self.message + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -721,25 +779,27 @@ 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(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: - kwargs["message"] = de.read_string(members[0]) + kwargs["message"] = de.read_string( + _SCHEMA_VALIDATION_EXCEPTION.members["message"] + ) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct(_SCHEMA_VALIDATION_EXCEPTION, consumer=_consumer) return kwargs GET_ASYNC_INVOKE = APIOperation( input=GetAsyncInvokeInput, output=GetAsyncInvokeOutput, - static_schema=_SCHEMA_GET_ASYNC_INVOKE, + schema=_SCHEMA_GET_ASYNC_INVOKE, + input_schema=_SCHEMA_GET_ASYNC_INVOKE_INPUT, + output_schema=_SCHEMA_GET_ASYNC_INVOKE_OUTPUT, error_registry=TypeRegistry( { ShapeID( @@ -760,6 +820,12 @@ def _consumer(member_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, + ], ) @@ -801,30 +867,46 @@ class ListAsyncInvokesInput: """The sorting order for the response.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_LIST_ASYNC_INVOKES_INPUT), self) + serializer.write_struct(_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(members[0], self.submit_time_after) + serializer.write_timestamp( + _SCHEMA_LIST_ASYNC_INVOKES_INPUT.members["submitTimeAfter"], + self.submit_time_after, + ) if self.submit_time_before is not None: - serializer.write_timestamp(members[1], self.submit_time_before) + serializer.write_timestamp( + _SCHEMA_LIST_ASYNC_INVOKES_INPUT.members["submitTimeBefore"], + self.submit_time_before, + ) if self.status_equals is not None: - serializer.write_string(members[2], self.status_equals) + serializer.write_string( + _SCHEMA_LIST_ASYNC_INVOKES_INPUT.members["statusEquals"], + self.status_equals, + ) if self.max_results is not None: - serializer.write_integer(members[3], self.max_results) + serializer.write_integer( + _SCHEMA_LIST_ASYNC_INVOKES_INPUT.members["maxResults"], self.max_results + ) if self.next_token is not None: - serializer.write_string(members[4], self.next_token) + serializer.write_string( + _SCHEMA_LIST_ASYNC_INVOKES_INPUT.members["nextToken"], self.next_token + ) if self.sort_by is not None: - serializer.write_string(members[5], self.sort_by) + serializer.write_string( + _SCHEMA_LIST_ASYNC_INVOKES_INPUT.members["sortBy"], self.sort_by + ) if self.sort_order is not None: - serializer.write_string(members[6], self.sort_order) + serializer.write_string( + _SCHEMA_LIST_ASYNC_INVOKES_INPUT.members["sortOrder"], self.sort_order + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -833,40 +915,54 @@ 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(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: - kwargs["submit_time_after"] = de.read_timestamp(members[0]) + kwargs["submit_time_after"] = de.read_timestamp( + _SCHEMA_LIST_ASYNC_INVOKES_INPUT.members["submitTimeAfter"] + ) case 1: - kwargs["submit_time_before"] = de.read_timestamp(members[1]) + kwargs["submit_time_before"] = de.read_timestamp( + _SCHEMA_LIST_ASYNC_INVOKES_INPUT.members["submitTimeBefore"] + ) case 2: kwargs["status_equals"] = AsyncInvokeStatus( - de.read_string(members[2]) + de.read_string( + _SCHEMA_LIST_ASYNC_INVOKES_INPUT.members["statusEquals"] + ) ) case 3: - kwargs["max_results"] = de.read_integer(members[3]) + kwargs["max_results"] = de.read_integer( + _SCHEMA_LIST_ASYNC_INVOKES_INPUT.members["maxResults"] + ) case 4: - kwargs["next_token"] = de.read_string(members[4]) + kwargs["next_token"] = de.read_string( + _SCHEMA_LIST_ASYNC_INVOKES_INPUT.members["nextToken"] + ) case 5: kwargs["sort_by"] = SortAsyncInvocationBy( - de.read_string(members[5]) + de.read_string( + _SCHEMA_LIST_ASYNC_INVOKES_INPUT.members["sortBy"] + ) ) case 6: - kwargs["sort_order"] = SortOrder(de.read_string(members[6])) + kwargs["sort_order"] = SortOrder( + de.read_string( + _SCHEMA_LIST_ASYNC_INVOKES_INPUT.members["sortOrder"] + ) + ) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct(_SCHEMA_LIST_ASYNC_INVOKES_INPUT, consumer=_consumer) return kwargs @@ -902,29 +998,50 @@ class AsyncInvokeSummary: """When the invocation ended.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_ASYNC_INVOKE_SUMMARY), self) + serializer.write_struct(_SCHEMA_ASYNC_INVOKE_SUMMARY, self) def serialize_members(self, serializer: ShapeSerializer): - 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) + serializer.write_string( + _SCHEMA_ASYNC_INVOKE_SUMMARY.members["invocationArn"], self.invocation_arn + ) + serializer.write_string( + _SCHEMA_ASYNC_INVOKE_SUMMARY.members["modelArn"], self.model_arn + ) if self.client_request_token is not None: - serializer.write_string(members[2], self.client_request_token) + serializer.write_string( + _SCHEMA_ASYNC_INVOKE_SUMMARY.members["clientRequestToken"], + self.client_request_token, + ) if self.status is not None: - serializer.write_string(members[3], self.status) + serializer.write_string( + _SCHEMA_ASYNC_INVOKE_SUMMARY.members["status"], self.status + ) if self.failure_message is not None: - serializer.write_string(members[4], self.failure_message) + serializer.write_string( + _SCHEMA_ASYNC_INVOKE_SUMMARY.members["failureMessage"], + self.failure_message, + ) - serializer.write_timestamp(members[5], self.submit_time) + serializer.write_timestamp( + _SCHEMA_ASYNC_INVOKE_SUMMARY.members["submitTime"], self.submit_time + ) if self.last_modified_time is not None: - serializer.write_timestamp(members[6], self.last_modified_time) + serializer.write_timestamp( + _SCHEMA_ASYNC_INVOKE_SUMMARY.members["lastModifiedTime"], + self.last_modified_time, + ) if self.end_time is not None: - serializer.write_timestamp(members[7], self.end_time) + serializer.write_timestamp( + _SCHEMA_ASYNC_INVOKE_SUMMARY.members["endTime"], self.end_time + ) - serializer.write_struct(members[8], self.output_data_config) + serializer.write_struct( + _SCHEMA_ASYNC_INVOKE_SUMMARY.members["outputDataConfig"], + self.output_data_config, + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -933,34 +1050,48 @@ 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(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: - kwargs["invocation_arn"] = de.read_string(members[0]) + kwargs["invocation_arn"] = de.read_string( + _SCHEMA_ASYNC_INVOKE_SUMMARY.members["invocationArn"] + ) case 1: - kwargs["model_arn"] = de.read_string(members[1]) + kwargs["model_arn"] = de.read_string( + _SCHEMA_ASYNC_INVOKE_SUMMARY.members["modelArn"] + ) case 2: - kwargs["client_request_token"] = de.read_string(members[2]) + kwargs["client_request_token"] = de.read_string( + _SCHEMA_ASYNC_INVOKE_SUMMARY.members["clientRequestToken"] + ) case 3: - kwargs["status"] = AsyncInvokeStatus(de.read_string(members[3])) + kwargs["status"] = AsyncInvokeStatus( + de.read_string(_SCHEMA_ASYNC_INVOKE_SUMMARY.members["status"]) + ) case 4: - kwargs["failure_message"] = de.read_string(members[4]) + kwargs["failure_message"] = de.read_string( + _SCHEMA_ASYNC_INVOKE_SUMMARY.members["failureMessage"] + ) case 5: - kwargs["submit_time"] = de.read_timestamp(members[5]) + kwargs["submit_time"] = de.read_timestamp( + _SCHEMA_ASYNC_INVOKE_SUMMARY.members["submitTime"] + ) case 6: - kwargs["last_modified_time"] = de.read_timestamp(members[6]) + kwargs["last_modified_time"] = de.read_timestamp( + _SCHEMA_ASYNC_INVOKE_SUMMARY.members["lastModifiedTime"] + ) case 7: - kwargs["end_time"] = de.read_timestamp(members[7]) + kwargs["end_time"] = de.read_timestamp( + _SCHEMA_ASYNC_INVOKE_SUMMARY.members["endTime"] + ) case 8: kwargs["output_data_config"] = ( @@ -968,9 +1099,9 @@ def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: ) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct(_SCHEMA_ASYNC_INVOKE_SUMMARY, consumer=_consumer) if "invocation_arn" not in kwargs: kwargs["invocation_arn"] = "" if "model_arn" not in kwargs: @@ -985,7 +1116,7 @@ def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: def _serialize_async_invoke_summaries( serializer: ShapeSerializer, schema: Schema, value: list[AsyncInvokeSummary] ) -> None: - member_schema = schema.members_by_index[0] + member_schema = schema.members["member"] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_struct(member_schema, e) @@ -1031,16 +1162,19 @@ class ListAsyncInvokesOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_LIST_ASYNC_INVOKES_OUTPUT), self) + serializer.write_struct(_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(members[0], self.next_token) + serializer.write_string( + _SCHEMA_LIST_ASYNC_INVOKES_OUTPUT.members["nextToken"], self.next_token + ) if self.async_invoke_summaries is not None: _serialize_async_invoke_summaries( - serializer, members[1], self.async_invoke_summaries + serializer, + _SCHEMA_LIST_ASYNC_INVOKES_OUTPUT.members["asyncInvokeSummaries"], + self.async_invoke_summaries, ) @classmethod @@ -1050,30 +1184,37 @@ 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(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: - kwargs["next_token"] = de.read_string(members[0]) + kwargs["next_token"] = de.read_string( + _SCHEMA_LIST_ASYNC_INVOKES_OUTPUT.members["nextToken"] + ) case 1: kwargs["async_invoke_summaries"] = ( - _deserialize_async_invoke_summaries(de, members[1]) + _deserialize_async_invoke_summaries( + de, + _SCHEMA_LIST_ASYNC_INVOKES_OUTPUT.members[ + "asyncInvokeSummaries" + ], + ) ) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct(_SCHEMA_LIST_ASYNC_INVOKES_OUTPUT, consumer=_consumer) return kwargs LIST_ASYNC_INVOKES = APIOperation( input=ListAsyncInvokesInput, output=ListAsyncInvokesOutput, - static_schema=_SCHEMA_LIST_ASYNC_INVOKES, + schema=_SCHEMA_LIST_ASYNC_INVOKES, + input_schema=_SCHEMA_LIST_ASYNC_INVOKES_INPUT, + output_schema=_SCHEMA_LIST_ASYNC_INVOKES_OUTPUT, error_registry=TypeRegistry( { ShapeID( @@ -1094,6 +1235,12 @@ def _consumer(member_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, + ], ) @@ -1104,12 +1251,13 @@ class ConflictException(ServiceError): fault: Literal["client", "server"] | None = "client" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_CONFLICT_EXCEPTION), self) + serializer.write_struct(_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(members[0], self.message) + serializer.write_string( + _SCHEMA_CONFLICT_EXCEPTION.members["message"], self.message + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -1118,18 +1266,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(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: - kwargs["message"] = de.read_string(members[0]) + kwargs["message"] = de.read_string( + _SCHEMA_CONFLICT_EXCEPTION.members["message"] + ) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct(_SCHEMA_CONFLICT_EXCEPTION, consumer=_consumer) return kwargs @@ -1145,12 +1293,13 @@ class ResourceNotFoundException(ServiceError): fault: Literal["client", "server"] | None = "client" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_RESOURCE_NOT_FOUND_EXCEPTION), self) + serializer.write_struct(_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(members[0], self.message) + serializer.write_string( + _SCHEMA_RESOURCE_NOT_FOUND_EXCEPTION.members["message"], self.message + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -1159,18 +1308,20 @@ 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(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: - kwargs["message"] = de.read_string(members[0]) + kwargs["message"] = de.read_string( + _SCHEMA_RESOURCE_NOT_FOUND_EXCEPTION.members["message"] + ) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct( + _SCHEMA_RESOURCE_NOT_FOUND_EXCEPTION, consumer=_consumer + ) return kwargs @@ -1186,12 +1337,14 @@ class ServiceQuotaExceededException(ServiceError): fault: Literal["client", "server"] | None = "client" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_SERVICE_QUOTA_EXCEEDED_EXCEPTION), self) + serializer.write_struct(_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(members[0], self.message) + serializer.write_string( + _SCHEMA_SERVICE_QUOTA_EXCEEDED_EXCEPTION.members["message"], + self.message, + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -1200,18 +1353,20 @@ 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(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: - kwargs["message"] = de.read_string(members[0]) + kwargs["message"] = de.read_string( + _SCHEMA_SERVICE_QUOTA_EXCEEDED_EXCEPTION.members["message"] + ) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct( + _SCHEMA_SERVICE_QUOTA_EXCEEDED_EXCEPTION, consumer=_consumer + ) return kwargs @@ -1227,12 +1382,13 @@ class ServiceUnavailableException(ServiceError): fault: Literal["client", "server"] | None = "server" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_SERVICE_UNAVAILABLE_EXCEPTION), self) + serializer.write_struct(_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(members[0], self.message) + serializer.write_string( + _SCHEMA_SERVICE_UNAVAILABLE_EXCEPTION.members["message"], self.message + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -1241,18 +1397,20 @@ 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(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: - kwargs["message"] = de.read_string(members[0]) + kwargs["message"] = de.read_string( + _SCHEMA_SERVICE_UNAVAILABLE_EXCEPTION.members["message"] + ) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct( + _SCHEMA_SERVICE_UNAVAILABLE_EXCEPTION, consumer=_consumer + ) return kwargs @@ -1267,12 +1425,11 @@ class Tag: """The tag's value.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_TAG), self) + serializer.write_struct(_SCHEMA_TAG, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_TAG).members_by_index - serializer.write_string(members[0], self.key) - serializer.write_string(members[1], self.value) + serializer.write_string(_SCHEMA_TAG.members["key"], self.key) + serializer.write_string(_SCHEMA_TAG.members["value"], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -1281,21 +1438,19 @@ 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(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: - kwargs["key"] = de.read_string(members[0]) + kwargs["key"] = de.read_string(_SCHEMA_TAG.members["key"]) case 1: - kwargs["value"] = de.read_string(members[1]) + kwargs["value"] = de.read_string(_SCHEMA_TAG.members["value"]) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct(_SCHEMA_TAG, consumer=_consumer) if "key" not in kwargs: kwargs["key"] = "" if "value" not in kwargs: @@ -1306,7 +1461,7 @@ def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: def _serialize_tag_list( serializer: ShapeSerializer, schema: Schema, value: list[Tag] ) -> None: - member_schema = schema.members_by_index[0] + member_schema = schema.members["member"] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_struct(member_schema, e) @@ -1346,24 +1501,35 @@ class StartAsyncInvokeInput: """Tags to apply to the invocation.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_START_ASYNC_INVOKE_INPUT), self) + serializer.write_struct(_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(members[0], self.client_request_token) + serializer.write_string( + _SCHEMA_START_ASYNC_INVOKE_INPUT.members["clientRequestToken"], + self.client_request_token, + ) if self.model_id is not None: - serializer.write_string(members[1], self.model_id) + serializer.write_string( + _SCHEMA_START_ASYNC_INVOKE_INPUT.members["modelId"], self.model_id + ) if self.model_input is not None: - serializer.write_document(members[2], self.model_input) + serializer.write_document( + _SCHEMA_START_ASYNC_INVOKE_INPUT.members["modelInput"], self.model_input + ) if self.output_data_config is not None: - serializer.write_struct(members[3], self.output_data_config) + serializer.write_struct( + _SCHEMA_START_ASYNC_INVOKE_INPUT.members["outputDataConfig"], + self.output_data_config, + ) if self.tags is not None: - _serialize_tag_list(serializer, members[4], self.tags) + _serialize_tag_list( + serializer, _SCHEMA_START_ASYNC_INVOKE_INPUT.members["tags"], self.tags + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -1372,19 +1538,23 @@ 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(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: - kwargs["client_request_token"] = de.read_string(members[0]) + kwargs["client_request_token"] = de.read_string( + _SCHEMA_START_ASYNC_INVOKE_INPUT.members["clientRequestToken"] + ) case 1: - kwargs["model_id"] = de.read_string(members[1]) + kwargs["model_id"] = de.read_string( + _SCHEMA_START_ASYNC_INVOKE_INPUT.members["modelId"] + ) case 2: - kwargs["model_input"] = de.read_document(members[2]) + kwargs["model_input"] = de.read_document( + _SCHEMA_START_ASYNC_INVOKE_INPUT.members["modelInput"] + ) case 3: kwargs["output_data_config"] = ( @@ -1392,12 +1562,14 @@ def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: ) case 4: - kwargs["tags"] = _deserialize_tag_list(de, members[4]) + kwargs["tags"] = _deserialize_tag_list( + de, _SCHEMA_START_ASYNC_INVOKE_INPUT.members["tags"] + ) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct(_SCHEMA_START_ASYNC_INVOKE_INPUT, consumer=_consumer) return kwargs @@ -1419,11 +1591,13 @@ class StartAsyncInvokeOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_START_ASYNC_INVOKE_OUTPUT), self) + serializer.write_struct(_SCHEMA_START_ASYNC_INVOKE_OUTPUT, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_START_ASYNC_INVOKE_OUTPUT).members_by_index - serializer.write_string(members[0], self.invocation_arn) + serializer.write_string( + _SCHEMA_START_ASYNC_INVOKE_OUTPUT.members["invocationArn"], + self.invocation_arn, + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -1432,18 +1606,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(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: - kwargs["invocation_arn"] = de.read_string(members[0]) + kwargs["invocation_arn"] = de.read_string( + _SCHEMA_START_ASYNC_INVOKE_OUTPUT.members["invocationArn"] + ) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct(_SCHEMA_START_ASYNC_INVOKE_OUTPUT, consumer=_consumer) if "invocation_arn" not in kwargs: kwargs["invocation_arn"] = "" return kwargs @@ -1452,7 +1626,9 @@ def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: START_ASYNC_INVOKE = APIOperation( input=StartAsyncInvokeInput, output=StartAsyncInvokeOutput, - static_schema=_SCHEMA_START_ASYNC_INVOKE, + schema=_SCHEMA_START_ASYNC_INVOKE, + input_schema=_SCHEMA_START_ASYNC_INVOKE_INPUT, + output_schema=_SCHEMA_START_ASYNC_INVOKE_OUTPUT, error_registry=TypeRegistry( { ShapeID( @@ -1485,6 +1661,16 @@ def _consumer(member_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, + ], ) @@ -1503,16 +1689,20 @@ class GuardrailImageSourceBytes: value: bytes def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_GUARDRAIL_IMAGE_SOURCE), self) + serializer.write_struct(_SCHEMA_GUARDRAIL_IMAGE_SOURCE, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_GUARDRAIL_IMAGE_SOURCE).members_by_index - serializer.write_blob(members[0], self.value) + serializer.write_blob( + _SCHEMA_GUARDRAIL_IMAGE_SOURCE.members["bytes"], self.value + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: - members = hydrate(_SCHEMA_GUARDRAIL_IMAGE_SOURCE).members_by_index - return cls(value=deserializer.read_blob(members[0])) + return cls( + value=deserializer.read_blob( + _SCHEMA_GUARDRAIL_IMAGE_SOURCE.members["bytes"] + ) + ) @dataclass @@ -1551,9 +1741,7 @@ class _GuardrailImageSourceDeserializer: def deserialize(self, deserializer: ShapeDeserializer) -> GuardrailImageSource: self._result = None - deserializer.read_struct( - hydrate(_SCHEMA_GUARDRAIL_IMAGE_SOURCE), self._consumer - ) + deserializer.read_struct(_SCHEMA_GUARDRAIL_IMAGE_SOURCE, self._consumer) if self._result is None: raise SerializationError( @@ -1600,12 +1788,15 @@ class GuardrailImageBlock: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_GUARDRAIL_IMAGE_BLOCK), self) + serializer.write_struct(_SCHEMA_GUARDRAIL_IMAGE_BLOCK, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_GUARDRAIL_IMAGE_BLOCK).members_by_index - serializer.write_string(members[0], self.format) - serializer.write_struct(members[1], self.source) + serializer.write_string( + _SCHEMA_GUARDRAIL_IMAGE_BLOCK.members["format"], self.format + ) + serializer.write_struct( + _SCHEMA_GUARDRAIL_IMAGE_BLOCK.members["source"], self.source + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -1614,13 +1805,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(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: - kwargs["format"] = GuardrailImageFormat(de.read_string(members[0])) + kwargs["format"] = GuardrailImageFormat( + de.read_string(_SCHEMA_GUARDRAIL_IMAGE_BLOCK.members["format"]) + ) case 1: kwargs["source"] = _GuardrailImageSourceDeserializer().deserialize( @@ -1628,9 +1819,9 @@ def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: ) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct(_SCHEMA_GUARDRAIL_IMAGE_BLOCK, consumer=_consumer) if "format" not in kwargs: kwargs["format"] = GuardrailImageFormat._corrected("") if "source" not in kwargs: @@ -1647,7 +1838,7 @@ class GuardrailContentQualifier(UnknownEnumMixin, StrEnum): def _serialize_guardrail_content_qualifier_list( serializer: ShapeSerializer, schema: Schema, value: list[str] ) -> None: - member_schema = schema.members_by_index[0] + member_schema = schema.members["member"] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_string(member_schema, e) @@ -1657,7 +1848,7 @@ def _deserialize_guardrail_content_qualifier_list( deserializer: ShapeDeserializer, schema: Schema ) -> list[str]: result: list[str] = [] - member_schema = schema.members_by_index[0] + member_schema = schema.members["member"] def _read_value(d: ShapeDeserializer): if d.is_null(): @@ -1681,14 +1872,15 @@ class GuardrailTextBlock: """The qualifiers describing the text block.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_GUARDRAIL_TEXT_BLOCK), self) + serializer.write_struct(_SCHEMA_GUARDRAIL_TEXT_BLOCK, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_GUARDRAIL_TEXT_BLOCK).members_by_index - serializer.write_string(members[0], self.text) + serializer.write_string(_SCHEMA_GUARDRAIL_TEXT_BLOCK.members["text"], self.text) if self.qualifiers is not None: _serialize_guardrail_content_qualifier_list( - serializer, members[1], self.qualifiers + serializer, + _SCHEMA_GUARDRAIL_TEXT_BLOCK.members["qualifiers"], + self.qualifiers, ) @classmethod @@ -1698,23 +1890,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_TEXT_BLOCK) - members = schema.members_by_index - def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: - kwargs["text"] = de.read_string(members[0]) + kwargs["text"] = de.read_string( + _SCHEMA_GUARDRAIL_TEXT_BLOCK.members["text"] + ) case 1: kwargs["qualifiers"] = ( - _deserialize_guardrail_content_qualifier_list(de, members[1]) + _deserialize_guardrail_content_qualifier_list( + de, _SCHEMA_GUARDRAIL_TEXT_BLOCK.members["qualifiers"] + ) ) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct(_SCHEMA_GUARDRAIL_TEXT_BLOCK, consumer=_consumer) if "text" not in kwargs: kwargs["text"] = "" return kwargs @@ -1727,11 +1921,12 @@ class GuardrailContentBlockText: value: GuardrailTextBlock def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_GUARDRAIL_CONTENT_BLOCK), self) + serializer.write_struct(_SCHEMA_GUARDRAIL_CONTENT_BLOCK, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_GUARDRAIL_CONTENT_BLOCK).members_by_index - serializer.write_struct(members[0], self.value) + serializer.write_struct( + _SCHEMA_GUARDRAIL_CONTENT_BLOCK.members["text"], self.value + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -1745,11 +1940,12 @@ class GuardrailContentBlockImage: value: GuardrailImageBlock def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_GUARDRAIL_CONTENT_BLOCK), self) + serializer.write_struct(_SCHEMA_GUARDRAIL_CONTENT_BLOCK, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_GUARDRAIL_CONTENT_BLOCK).members_by_index - serializer.write_struct(members[1], self.value) + serializer.write_struct( + _SCHEMA_GUARDRAIL_CONTENT_BLOCK.members["image"], self.value + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -1793,9 +1989,7 @@ class _GuardrailContentBlockDeserializer: def deserialize(self, deserializer: ShapeDeserializer) -> GuardrailContentBlock: self._result = None - deserializer.read_struct( - hydrate(_SCHEMA_GUARDRAIL_CONTENT_BLOCK), self._consumer - ) + deserializer.read_struct(_SCHEMA_GUARDRAIL_CONTENT_BLOCK, self._consumer) if self._result is None: raise SerializationError( @@ -1828,7 +2022,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_by_index[0] + member_schema = schema.members["member"] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_struct(member_schema, e) @@ -1889,26 +2083,37 @@ class ApplyGuardrailInput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_APPLY_GUARDRAIL_INPUT), self) + serializer.write_struct(_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(members[0], self.guardrail_identifier) + serializer.write_string( + _SCHEMA_APPLY_GUARDRAIL_INPUT.members["guardrailIdentifier"], + self.guardrail_identifier, + ) if self.guardrail_version is not None: - serializer.write_string(members[1], self.guardrail_version) + serializer.write_string( + _SCHEMA_APPLY_GUARDRAIL_INPUT.members["guardrailVersion"], + self.guardrail_version, + ) if self.source is not None: - serializer.write_string(members[2], self.source) + serializer.write_string( + _SCHEMA_APPLY_GUARDRAIL_INPUT.members["source"], self.source + ) if self.content is not None: _serialize_guardrail_content_block_list( - serializer, members[3], self.content + serializer, + _SCHEMA_APPLY_GUARDRAIL_INPUT.members["content"], + self.content, ) if self.output_scope is not None: - serializer.write_string(members[4], self.output_scope) + serializer.write_string( + _SCHEMA_APPLY_GUARDRAIL_INPUT.members["outputScope"], self.output_scope + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -1917,36 +2122,40 @@ 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(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: - kwargs["guardrail_identifier"] = de.read_string(members[0]) + kwargs["guardrail_identifier"] = de.read_string( + _SCHEMA_APPLY_GUARDRAIL_INPUT.members["guardrailIdentifier"] + ) case 1: - kwargs["guardrail_version"] = de.read_string(members[1]) + kwargs["guardrail_version"] = de.read_string( + _SCHEMA_APPLY_GUARDRAIL_INPUT.members["guardrailVersion"] + ) case 2: kwargs["source"] = GuardrailContentSource( - de.read_string(members[2]) + de.read_string(_SCHEMA_APPLY_GUARDRAIL_INPUT.members["source"]) ) case 3: kwargs["content"] = _deserialize_guardrail_content_block_list( - de, members[3] + de, _SCHEMA_APPLY_GUARDRAIL_INPUT.members["content"] ) case 4: kwargs["output_scope"] = GuardrailOutputScope( - de.read_string(members[4]) + de.read_string( + _SCHEMA_APPLY_GUARDRAIL_INPUT.members["outputScope"] + ) ) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct(_SCHEMA_APPLY_GUARDRAIL_INPUT, consumer=_consumer) return kwargs @@ -1964,7 +2173,7 @@ class GuardrailOrigin(UnknownEnumMixin, StrEnum): def _serialize_guardrail_origin_list( serializer: ShapeSerializer, schema: Schema, value: list[str] ) -> None: - member_schema = schema.members_by_index[0] + member_schema = schema.members["member"] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_string(member_schema, e) @@ -1974,7 +2183,7 @@ def _deserialize_guardrail_origin_list( deserializer: ShapeDeserializer, schema: Schema ) -> list[str]: result: list[str] = [] - member_schema = schema.members_by_index[0] + member_schema = schema.members["member"] def _read_value(d: ShapeDeserializer): if d.is_null(): @@ -2024,26 +2233,39 @@ class AppliedGuardrailDetails: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_APPLIED_GUARDRAIL_DETAILS), self) + serializer.write_struct(_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(members[0], self.guardrail_id) + serializer.write_string( + _SCHEMA_APPLIED_GUARDRAIL_DETAILS.members["guardrailId"], + self.guardrail_id, + ) if self.guardrail_version is not None: - serializer.write_string(members[1], self.guardrail_version) + serializer.write_string( + _SCHEMA_APPLIED_GUARDRAIL_DETAILS.members["guardrailVersion"], + self.guardrail_version, + ) if self.guardrail_arn is not None: - serializer.write_string(members[2], self.guardrail_arn) + serializer.write_string( + _SCHEMA_APPLIED_GUARDRAIL_DETAILS.members["guardrailArn"], + self.guardrail_arn, + ) if self.guardrail_origin is not None: _serialize_guardrail_origin_list( - serializer, members[3], self.guardrail_origin + serializer, + _SCHEMA_APPLIED_GUARDRAIL_DETAILS.members["guardrailOrigin"], + self.guardrail_origin, ) if self.guardrail_ownership is not None: - serializer.write_string(members[4], self.guardrail_ownership) + serializer.write_string( + _SCHEMA_APPLIED_GUARDRAIL_DETAILS.members["guardrailOwnership"], + self.guardrail_ownership, + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -2052,34 +2274,42 @@ 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(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: - kwargs["guardrail_id"] = de.read_string(members[0]) + kwargs["guardrail_id"] = de.read_string( + _SCHEMA_APPLIED_GUARDRAIL_DETAILS.members["guardrailId"] + ) case 1: - kwargs["guardrail_version"] = de.read_string(members[1]) + kwargs["guardrail_version"] = de.read_string( + _SCHEMA_APPLIED_GUARDRAIL_DETAILS.members["guardrailVersion"] + ) case 2: - kwargs["guardrail_arn"] = de.read_string(members[2]) + kwargs["guardrail_arn"] = de.read_string( + _SCHEMA_APPLIED_GUARDRAIL_DETAILS.members["guardrailArn"] + ) case 3: kwargs["guardrail_origin"] = _deserialize_guardrail_origin_list( - de, members[3] + de, _SCHEMA_APPLIED_GUARDRAIL_DETAILS.members["guardrailOrigin"] ) case 4: kwargs["guardrail_ownership"] = GuardrailOwnership( - de.read_string(members[4]) + de.read_string( + _SCHEMA_APPLIED_GUARDRAIL_DETAILS.members[ + "guardrailOwnership" + ] + ) ) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct(_SCHEMA_APPLIED_GUARDRAIL_DETAILS, consumer=_consumer) return kwargs @@ -2100,17 +2330,20 @@ class GuardrailAutomatedReasoningRule: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct( - hydrate(_SCHEMA_GUARDRAIL_AUTOMATED_REASONING_RULE), self - ) + serializer.write_struct(_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(members[0], self.identifier) + serializer.write_string( + _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_RULE.members["identifier"], + self.identifier, + ) if self.policy_version_arn is not None: - serializer.write_string(members[1], self.policy_version_arn) + serializer.write_string( + _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_RULE.members["policyVersionArn"], + self.policy_version_arn, + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -2119,21 +2352,27 @@ 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(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: - kwargs["identifier"] = de.read_string(members[0]) + kwargs["identifier"] = de.read_string( + _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_RULE.members["identifier"] + ) case 1: - kwargs["policy_version_arn"] = de.read_string(members[1]) + kwargs["policy_version_arn"] = de.read_string( + _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_RULE.members[ + "policyVersionArn" + ] + ) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct( + _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_RULE, consumer=_consumer + ) return kwargs @@ -2142,7 +2381,7 @@ def _serialize_guardrail_automated_reasoning_rule_list( schema: Schema, value: list[GuardrailAutomatedReasoningRule], ) -> None: - member_schema = schema.members_by_index[0] + member_schema = schema.members["member"] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_struct(member_schema, e) @@ -2178,19 +2417,22 @@ class GuardrailAutomatedReasoningStatement: """The natural language explanation of the logical statement.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct( - hydrate(_SCHEMA_GUARDRAIL_AUTOMATED_REASONING_STATEMENT), self - ) + serializer.write_struct(_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(members[0], self.logic) + serializer.write_string( + _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_STATEMENT.members["logic"], + self.logic, + ) if self.natural_language is not None: - serializer.write_string(members[1], self.natural_language) + serializer.write_string( + _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_STATEMENT.members[ + "naturalLanguage" + ], + self.natural_language, + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -2199,21 +2441,27 @@ 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(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: - kwargs["logic"] = de.read_string(members[0]) + kwargs["logic"] = de.read_string( + _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_STATEMENT.members["logic"] + ) case 1: - kwargs["natural_language"] = de.read_string(members[1]) + kwargs["natural_language"] = de.read_string( + _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_STATEMENT.members[ + "naturalLanguage" + ] + ) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct( + _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_STATEMENT, consumer=_consumer + ) return kwargs @@ -2222,7 +2470,7 @@ def _serialize_guardrail_automated_reasoning_statement_list( schema: Schema, value: list[GuardrailAutomatedReasoningStatement], ) -> None: - member_schema = schema.members_by_index[0] + member_schema = schema.members["member"] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_struct(member_schema, e) @@ -2277,24 +2525,28 @@ class GuardrailAutomatedReasoningLogicWarning: def serialize(self, serializer: ShapeSerializer): serializer.write_struct( - hydrate(_SCHEMA_GUARDRAIL_AUTOMATED_REASONING_LOGIC_WARNING), self + _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(members[0], self.type) + serializer.write_string( + _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_LOGIC_WARNING.members["type"], + self.type, + ) if self.premises is not None: _serialize_guardrail_automated_reasoning_statement_list( - serializer, members[1], self.premises + serializer, + _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_LOGIC_WARNING.members["premises"], + self.premises, ) if self.claims is not None: _serialize_guardrail_automated_reasoning_statement_list( - serializer, members[2], self.claims + serializer, + _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_LOGIC_WARNING.members["claims"], + self.claims, ) @classmethod @@ -2304,34 +2556,44 @@ 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(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: kwargs["type"] = GuardrailAutomatedReasoningLogicWarningType( - de.read_string(members[0]) + de.read_string( + _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_LOGIC_WARNING.members[ + "type" + ] + ) ) case 1: kwargs["premises"] = ( _deserialize_guardrail_automated_reasoning_statement_list( - de, members[1] + de, + _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_LOGIC_WARNING.members[ + "premises" + ], ) ) case 2: kwargs["claims"] = ( _deserialize_guardrail_automated_reasoning_statement_list( - de, members[2] + de, + _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_LOGIC_WARNING.members[ + "claims" + ], ) ) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct( + _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_LOGIC_WARNING, consumer=_consumer + ) return kwargs @@ -2347,15 +2609,17 @@ class GuardrailAutomatedReasoningInputTextReference: def serialize(self, serializer: ShapeSerializer): serializer.write_struct( - hydrate(_SCHEMA_GUARDRAIL_AUTOMATED_REASONING_INPUT_TEXT_REFERENCE), self + _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(members[0], self.text) + serializer.write_string( + _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_INPUT_TEXT_REFERENCE.members[ + "text" + ], + self.text, + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -2364,18 +2628,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_AUTOMATED_REASONING_INPUT_TEXT_REFERENCE) - members = schema.members_by_index - def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: - kwargs["text"] = de.read_string(members[0]) + kwargs["text"] = de.read_string( + _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_INPUT_TEXT_REFERENCE.members[ + "text" + ] + ) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct( + _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_INPUT_TEXT_REFERENCE, + consumer=_consumer, + ) return kwargs @@ -2384,7 +2653,7 @@ def _serialize_guardrail_automated_reasoning_input_text_reference_list( schema: Schema, value: list[GuardrailAutomatedReasoningInputTextReference], ) -> None: - member_schema = schema.members_by_index[0] + member_schema = schema.members["member"] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_struct(member_schema, e) @@ -2448,36 +2717,46 @@ class GuardrailAutomatedReasoningTranslation: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct( - hydrate(_SCHEMA_GUARDRAIL_AUTOMATED_REASONING_TRANSLATION), self - ) + serializer.write_struct(_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, members[0], self.premises + serializer, + _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_TRANSLATION.members["premises"], + self.premises, ) if self.claims is not None: _serialize_guardrail_automated_reasoning_statement_list( - serializer, members[1], self.claims + serializer, + _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_TRANSLATION.members["claims"], + self.claims, ) if self.untranslated_premises is not None: _serialize_guardrail_automated_reasoning_input_text_reference_list( - serializer, members[2], self.untranslated_premises + serializer, + _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_TRANSLATION.members[ + "untranslatedPremises" + ], + self.untranslated_premises, ) if self.untranslated_claims is not None: _serialize_guardrail_automated_reasoning_input_text_reference_list( - serializer, members[3], self.untranslated_claims + serializer, + _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_TRANSLATION.members[ + "untranslatedClaims" + ], + self.untranslated_claims, ) if self.confidence is not None: - serializer.write_double(members[4], self.confidence) + serializer.write_double( + _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_TRANSLATION.members["confidence"], + self.confidence, + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -2486,46 +2765,62 @@ 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(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: kwargs["premises"] = ( _deserialize_guardrail_automated_reasoning_statement_list( - de, members[0] + de, + _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_TRANSLATION.members[ + "premises" + ], ) ) case 1: kwargs["claims"] = ( _deserialize_guardrail_automated_reasoning_statement_list( - de, members[1] + de, + _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_TRANSLATION.members[ + "claims" + ], ) ) case 2: kwargs["untranslated_premises"] = ( _deserialize_guardrail_automated_reasoning_input_text_reference_list( - de, members[2] + de, + _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_TRANSLATION.members[ + "untranslatedPremises" + ], ) ) case 3: kwargs["untranslated_claims"] = ( _deserialize_guardrail_automated_reasoning_input_text_reference_list( - de, members[3] + de, + _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_TRANSLATION.members[ + "untranslatedClaims" + ], ) ) case 4: - kwargs["confidence"] = de.read_double(members[4]) + kwargs["confidence"] = de.read_double( + _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_TRANSLATION.members[ + "confidence" + ] + ) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct( + _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_TRANSLATION, consumer=_consumer + ) return kwargs @@ -2553,23 +2848,34 @@ class GuardrailAutomatedReasoningImpossibleFinding: def serialize(self, serializer: ShapeSerializer): serializer.write_struct( - hydrate(_SCHEMA_GUARDRAIL_AUTOMATED_REASONING_IMPOSSIBLE_FINDING), self + _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(members[0], self.translation) + serializer.write_struct( + _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_IMPOSSIBLE_FINDING.members[ + "translation" + ], + self.translation, + ) if self.contradicting_rules is not None: _serialize_guardrail_automated_reasoning_rule_list( - serializer, members[1], self.contradicting_rules + serializer, + _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_IMPOSSIBLE_FINDING.members[ + "contradictingRules" + ], + self.contradicting_rules, ) if self.logic_warning is not None: - serializer.write_struct(members[2], self.logic_warning) + serializer.write_struct( + _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_IMPOSSIBLE_FINDING.members[ + "logicWarning" + ], + self.logic_warning, + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -2578,11 +2884,9 @@ 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(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: kwargs["translation"] = ( GuardrailAutomatedReasoningTranslation.deserialize(de) @@ -2591,7 +2895,10 @@ def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: case 1: kwargs["contradicting_rules"] = ( _deserialize_guardrail_automated_reasoning_rule_list( - de, members[1] + de, + _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_IMPOSSIBLE_FINDING.members[ + "contradictingRules" + ], ) ) @@ -2601,9 +2908,11 @@ def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: ) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct( + _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_IMPOSSIBLE_FINDING, consumer=_consumer + ) return kwargs @@ -2631,23 +2940,34 @@ class GuardrailAutomatedReasoningInvalidFinding: def serialize(self, serializer: ShapeSerializer): serializer.write_struct( - hydrate(_SCHEMA_GUARDRAIL_AUTOMATED_REASONING_INVALID_FINDING), self + _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(members[0], self.translation) + serializer.write_struct( + _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_INVALID_FINDING.members[ + "translation" + ], + self.translation, + ) if self.contradicting_rules is not None: _serialize_guardrail_automated_reasoning_rule_list( - serializer, members[1], self.contradicting_rules + serializer, + _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_INVALID_FINDING.members[ + "contradictingRules" + ], + self.contradicting_rules, ) if self.logic_warning is not None: - serializer.write_struct(members[2], self.logic_warning) + serializer.write_struct( + _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_INVALID_FINDING.members[ + "logicWarning" + ], + self.logic_warning, + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -2656,11 +2976,9 @@ 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(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: kwargs["translation"] = ( GuardrailAutomatedReasoningTranslation.deserialize(de) @@ -2669,7 +2987,10 @@ def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: case 1: kwargs["contradicting_rules"] = ( _deserialize_guardrail_automated_reasoning_rule_list( - de, members[1] + de, + _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_INVALID_FINDING.members[ + "contradictingRules" + ], ) ) @@ -2679,9 +3000,11 @@ def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: ) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct( + _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_INVALID_FINDING, consumer=_consumer + ) return kwargs @@ -2694,7 +3017,7 @@ class GuardrailAutomatedReasoningNoTranslationsFinding: def serialize(self, serializer: ShapeSerializer): serializer.write_struct( - hydrate(_SCHEMA_GUARDRAIL_AUTOMATED_REASONING_NO_TRANSLATIONS_FINDING), self + _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_NO_TRANSLATIONS_FINDING, self ) def serialize_members(self, serializer: ShapeSerializer): @@ -2707,14 +3030,16 @@ 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(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct( + _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_NO_TRANSLATIONS_FINDING, + consumer=_consumer, + ) return kwargs @@ -2729,17 +3054,14 @@ class GuardrailAutomatedReasoningScenario: """List of logical assignments and statements that define this scenario.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct( - hydrate(_SCHEMA_GUARDRAIL_AUTOMATED_REASONING_SCENARIO), self - ) + serializer.write_struct(_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, members[0], self.statements + serializer, + _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_SCENARIO.members["statements"], + self.statements, ) @classmethod @@ -2749,22 +3071,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_AUTOMATED_REASONING_SCENARIO) - members = schema.members_by_index - def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: kwargs["statements"] = ( _deserialize_guardrail_automated_reasoning_statement_list( - de, members[0] + de, + _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_SCENARIO.members[ + "statements" + ], ) ) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct( + _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_SCENARIO, consumer=_consumer + ) return kwargs @@ -2798,24 +3123,41 @@ class GuardrailAutomatedReasoningSatisfiableFinding: def serialize(self, serializer: ShapeSerializer): serializer.write_struct( - hydrate(_SCHEMA_GUARDRAIL_AUTOMATED_REASONING_SATISFIABLE_FINDING), self + _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(members[0], self.translation) + serializer.write_struct( + _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_SATISFIABLE_FINDING.members[ + "translation" + ], + self.translation, + ) if self.claims_true_scenario is not None: - serializer.write_struct(members[1], self.claims_true_scenario) + serializer.write_struct( + _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_SATISFIABLE_FINDING.members[ + "claimsTrueScenario" + ], + self.claims_true_scenario, + ) if self.claims_false_scenario is not None: - serializer.write_struct(members[2], self.claims_false_scenario) + serializer.write_struct( + _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_SATISFIABLE_FINDING.members[ + "claimsFalseScenario" + ], + self.claims_false_scenario, + ) if self.logic_warning is not None: - serializer.write_struct(members[3], self.logic_warning) + serializer.write_struct( + _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_SATISFIABLE_FINDING.members[ + "logicWarning" + ], + self.logic_warning, + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -2824,11 +3166,9 @@ 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(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: kwargs["translation"] = ( GuardrailAutomatedReasoningTranslation.deserialize(de) @@ -2850,9 +3190,12 @@ def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: ) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct( + _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_SATISFIABLE_FINDING, + consumer=_consumer, + ) return kwargs @@ -2865,7 +3208,7 @@ class GuardrailAutomatedReasoningTooComplexFinding: def serialize(self, serializer: ShapeSerializer): serializer.write_struct( - hydrate(_SCHEMA_GUARDRAIL_AUTOMATED_REASONING_TOO_COMPLEX_FINDING), self + _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_TOO_COMPLEX_FINDING, self ) def serialize_members(self, serializer: ShapeSerializer): @@ -2878,14 +3221,16 @@ 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(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct( + _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_TOO_COMPLEX_FINDING, + consumer=_consumer, + ) return kwargs @@ -2894,7 +3239,7 @@ def _serialize_guardrail_automated_reasoning_difference_scenario_list( schema: Schema, value: list[GuardrailAutomatedReasoningScenario], ) -> None: - member_schema = schema.members_by_index[0] + member_schema = schema.members["member"] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_struct(member_schema, e) @@ -2921,7 +3266,7 @@ def _serialize_guardrail_automated_reasoning_translation_list( schema: Schema, value: list[GuardrailAutomatedReasoningTranslation], ) -> None: - member_schema = schema.members_by_index[0] + member_schema = schema.members["member"] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_struct(member_schema, e) @@ -2958,16 +3303,17 @@ class GuardrailAutomatedReasoningTranslationOption: def serialize(self, serializer: ShapeSerializer): serializer.write_struct( - hydrate(_SCHEMA_GUARDRAIL_AUTOMATED_REASONING_TRANSLATION_OPTION), self + _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, members[0], self.translations + serializer, + _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_TRANSLATION_OPTION.members[ + "translations" + ], + self.translations, ) @classmethod @@ -2977,22 +3323,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_AUTOMATED_REASONING_TRANSLATION_OPTION) - members = schema.members_by_index - def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: kwargs["translations"] = ( _deserialize_guardrail_automated_reasoning_translation_list( - de, members[0] + de, + _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_TRANSLATION_OPTION.members[ + "translations" + ], ) ) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct( + _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_TRANSLATION_OPTION, consumer=_consumer + ) return kwargs @@ -3001,7 +3350,7 @@ def _serialize_guardrail_automated_reasoning_translation_option_list( schema: Schema, value: list[GuardrailAutomatedReasoningTranslationOption], ) -> None: - member_schema = schema.members_by_index[0] + member_schema = schema.members["member"] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_struct(member_schema, e) @@ -3044,24 +3393,26 @@ class GuardrailAutomatedReasoningTranslationAmbiguousFinding: def serialize(self, serializer: ShapeSerializer): serializer.write_struct( - hydrate( - _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_TRANSLATION_AMBIGUOUS_FINDING - ), - self, + _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, members[0], self.options + serializer, + _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_TRANSLATION_AMBIGUOUS_FINDING.members[ + "options" + ], + self.options, ) if self.difference_scenarios is not None: _serialize_guardrail_automated_reasoning_difference_scenario_list( - serializer, members[1], self.difference_scenarios + serializer, + _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_TRANSLATION_AMBIGUOUS_FINDING.members[ + "differenceScenarios" + ], + self.difference_scenarios, ) @classmethod @@ -3071,31 +3422,36 @@ 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(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: kwargs["options"] = ( _deserialize_guardrail_automated_reasoning_translation_option_list( - de, members[0] + de, + _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_TRANSLATION_AMBIGUOUS_FINDING.members[ + "options" + ], ) ) case 1: kwargs["difference_scenarios"] = ( _deserialize_guardrail_automated_reasoning_difference_scenario_list( - de, members[1] + de, + _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_TRANSLATION_AMBIGUOUS_FINDING.members[ + "differenceScenarios" + ], ) ) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct( + _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_TRANSLATION_AMBIGUOUS_FINDING, + consumer=_consumer, + ) return kwargs @@ -3126,26 +3482,42 @@ class GuardrailAutomatedReasoningValidFinding: def serialize(self, serializer: ShapeSerializer): serializer.write_struct( - hydrate(_SCHEMA_GUARDRAIL_AUTOMATED_REASONING_VALID_FINDING), self + _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(members[0], self.translation) + serializer.write_struct( + _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_VALID_FINDING.members[ + "translation" + ], + self.translation, + ) if self.claims_true_scenario is not None: - serializer.write_struct(members[1], self.claims_true_scenario) + serializer.write_struct( + _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_VALID_FINDING.members[ + "claimsTrueScenario" + ], + self.claims_true_scenario, + ) if self.supporting_rules is not None: _serialize_guardrail_automated_reasoning_rule_list( - serializer, members[2], self.supporting_rules + serializer, + _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_VALID_FINDING.members[ + "supportingRules" + ], + self.supporting_rules, ) if self.logic_warning is not None: - serializer.write_struct(members[3], self.logic_warning) + serializer.write_struct( + _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_VALID_FINDING.members[ + "logicWarning" + ], + self.logic_warning, + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -3154,11 +3526,9 @@ 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(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: kwargs["translation"] = ( GuardrailAutomatedReasoningTranslation.deserialize(de) @@ -3172,7 +3542,10 @@ def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: case 2: kwargs["supporting_rules"] = ( _deserialize_guardrail_automated_reasoning_rule_list( - de, members[2] + de, + _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_VALID_FINDING.members[ + "supportingRules" + ], ) ) @@ -3182,9 +3555,11 @@ def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: ) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct( + _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_VALID_FINDING, consumer=_consumer + ) return kwargs @@ -3199,15 +3574,12 @@ class GuardrailAutomatedReasoningFindingValid: value: GuardrailAutomatedReasoningValidFinding def serialize(self, serializer: ShapeSerializer): - serializer.write_struct( - hydrate(_SCHEMA_GUARDRAIL_AUTOMATED_REASONING_FINDING), self - ) + serializer.write_struct(_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) + serializer.write_struct( + _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_FINDING.members["valid"], self.value + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -3227,15 +3599,12 @@ class GuardrailAutomatedReasoningFindingInvalid: value: GuardrailAutomatedReasoningInvalidFinding def serialize(self, serializer: ShapeSerializer): - serializer.write_struct( - hydrate(_SCHEMA_GUARDRAIL_AUTOMATED_REASONING_FINDING), self - ) + serializer.write_struct(_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) + serializer.write_struct( + _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_FINDING.members["invalid"], self.value + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -3255,15 +3624,13 @@ class GuardrailAutomatedReasoningFindingSatisfiable: value: GuardrailAutomatedReasoningSatisfiableFinding def serialize(self, serializer: ShapeSerializer): - serializer.write_struct( - hydrate(_SCHEMA_GUARDRAIL_AUTOMATED_REASONING_FINDING), self - ) + serializer.write_struct(_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) + serializer.write_struct( + _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_FINDING.members["satisfiable"], + self.value, + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -3285,15 +3652,13 @@ class GuardrailAutomatedReasoningFindingImpossible: value: GuardrailAutomatedReasoningImpossibleFinding def serialize(self, serializer: ShapeSerializer): - serializer.write_struct( - hydrate(_SCHEMA_GUARDRAIL_AUTOMATED_REASONING_FINDING), self - ) + serializer.write_struct(_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) + serializer.write_struct( + _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_FINDING.members["impossible"], + self.value, + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -3313,15 +3678,15 @@ class GuardrailAutomatedReasoningFindingTranslationAmbiguous: value: GuardrailAutomatedReasoningTranslationAmbiguousFinding def serialize(self, serializer: ShapeSerializer): - serializer.write_struct( - hydrate(_SCHEMA_GUARDRAIL_AUTOMATED_REASONING_FINDING), self - ) + serializer.write_struct(_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) + serializer.write_struct( + _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_FINDING.members[ + "translationAmbiguous" + ], + self.value, + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -3343,15 +3708,13 @@ class GuardrailAutomatedReasoningFindingTooComplex: value: GuardrailAutomatedReasoningTooComplexFinding def serialize(self, serializer: ShapeSerializer): - serializer.write_struct( - hydrate(_SCHEMA_GUARDRAIL_AUTOMATED_REASONING_FINDING), self - ) + serializer.write_struct(_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) + serializer.write_struct( + _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_FINDING.members["tooComplex"], + self.value, + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -3371,15 +3734,13 @@ class GuardrailAutomatedReasoningFindingNoTranslations: value: GuardrailAutomatedReasoningNoTranslationsFinding def serialize(self, serializer: ShapeSerializer): - serializer.write_struct( - hydrate(_SCHEMA_GUARDRAIL_AUTOMATED_REASONING_FINDING), self - ) + serializer.write_struct(_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) + serializer.write_struct( + _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_FINDING.members["noTranslations"], + self.value, + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -3440,7 +3801,7 @@ def deserialize( ) -> GuardrailAutomatedReasoningFinding: self._result = None deserializer.read_struct( - hydrate(_SCHEMA_GUARDRAIL_AUTOMATED_REASONING_FINDING), self._consumer + _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_FINDING, self._consumer ) if self._result is None: @@ -3509,7 +3870,7 @@ def _serialize_guardrail_automated_reasoning_finding_list( schema: Schema, value: list[GuardrailAutomatedReasoningFinding], ) -> None: - member_schema = schema.members_by_index[0] + member_schema = schema.members["member"] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_struct(member_schema, e) @@ -3548,16 +3909,17 @@ class GuardrailAutomatedReasoningPolicyAssessment: def serialize(self, serializer: ShapeSerializer): serializer.write_struct( - hydrate(_SCHEMA_GUARDRAIL_AUTOMATED_REASONING_POLICY_ASSESSMENT), self + _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, members[0], self.findings + serializer, + _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_POLICY_ASSESSMENT.members[ + "findings" + ], + self.findings, ) @classmethod @@ -3567,22 +3929,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_AUTOMATED_REASONING_POLICY_ASSESSMENT) - members = schema.members_by_index - def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: kwargs["findings"] = ( _deserialize_guardrail_automated_reasoning_finding_list( - de, members[0] + de, + _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_POLICY_ASSESSMENT.members[ + "findings" + ], ) ) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct( + _SCHEMA_GUARDRAIL_AUTOMATED_REASONING_POLICY_ASSESSMENT, consumer=_consumer + ) return kwargs @@ -3637,18 +4002,28 @@ class GuardrailContentFilter: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_GUARDRAIL_CONTENT_FILTER), self) + serializer.write_struct(_SCHEMA_GUARDRAIL_CONTENT_FILTER, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_GUARDRAIL_CONTENT_FILTER).members_by_index - serializer.write_string(members[0], self.type) - serializer.write_string(members[1], self.confidence) + serializer.write_string( + _SCHEMA_GUARDRAIL_CONTENT_FILTER.members["type"], self.type + ) + serializer.write_string( + _SCHEMA_GUARDRAIL_CONTENT_FILTER.members["confidence"], self.confidence + ) if self.filter_strength is not None: - serializer.write_string(members[2], self.filter_strength) + serializer.write_string( + _SCHEMA_GUARDRAIL_CONTENT_FILTER.members["filterStrength"], + self.filter_strength, + ) - serializer.write_string(members[3], self.action) + serializer.write_string( + _SCHEMA_GUARDRAIL_CONTENT_FILTER.members["action"], self.action + ) if self.detected is not None: - serializer.write_boolean(members[4], self.detected) + serializer.write_boolean( + _SCHEMA_GUARDRAIL_CONTENT_FILTER.members["detected"], self.detected + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -3657,38 +4032,44 @@ 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(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: kwargs["type"] = GuardrailContentFilterType( - de.read_string(members[0]) + de.read_string(_SCHEMA_GUARDRAIL_CONTENT_FILTER.members["type"]) ) case 1: kwargs["confidence"] = GuardrailContentFilterConfidence( - de.read_string(members[1]) + de.read_string( + _SCHEMA_GUARDRAIL_CONTENT_FILTER.members["confidence"] + ) ) case 2: kwargs["filter_strength"] = GuardrailContentFilterStrength( - de.read_string(members[2]) + de.read_string( + _SCHEMA_GUARDRAIL_CONTENT_FILTER.members["filterStrength"] + ) ) case 3: kwargs["action"] = GuardrailContentPolicyAction( - de.read_string(members[3]) + de.read_string( + _SCHEMA_GUARDRAIL_CONTENT_FILTER.members["action"] + ) ) case 4: - kwargs["detected"] = de.read_boolean(members[4]) + kwargs["detected"] = de.read_boolean( + _SCHEMA_GUARDRAIL_CONTENT_FILTER.members["detected"] + ) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct(_SCHEMA_GUARDRAIL_CONTENT_FILTER, consumer=_consumer) if "type" not in kwargs: kwargs["type"] = GuardrailContentFilterType._corrected("") if "confidence" not in kwargs: @@ -3701,7 +4082,7 @@ def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: def _serialize_guardrail_content_filter_list( serializer: ShapeSerializer, schema: Schema, value: list[GuardrailContentFilter] ) -> None: - member_schema = schema.members_by_index[0] + member_schema = schema.members["member"] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_struct(member_schema, e) @@ -3731,13 +4112,14 @@ class GuardrailContentPolicyAssessment: """The content policy filters.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct( - hydrate(_SCHEMA_GUARDRAIL_CONTENT_POLICY_ASSESSMENT), self - ) + serializer.write_struct(_SCHEMA_GUARDRAIL_CONTENT_POLICY_ASSESSMENT, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_GUARDRAIL_CONTENT_POLICY_ASSESSMENT).members_by_index - _serialize_guardrail_content_filter_list(serializer, members[0], self.filters) + _serialize_guardrail_content_filter_list( + serializer, + _SCHEMA_GUARDRAIL_CONTENT_POLICY_ASSESSMENT.members["filters"], + self.filters, + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -3746,20 +4128,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_CONTENT_POLICY_ASSESSMENT) - members = schema.members_by_index - def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: kwargs["filters"] = _deserialize_guardrail_content_filter_list( - de, members[0] + de, + _SCHEMA_GUARDRAIL_CONTENT_POLICY_ASSESSMENT.members["filters"], ) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct( + _SCHEMA_GUARDRAIL_CONTENT_POLICY_ASSESSMENT, consumer=_consumer + ) if "filters" not in kwargs: kwargs["filters"] = [] return kwargs @@ -3802,20 +4185,27 @@ class GuardrailContextualGroundingFilter: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct( - hydrate(_SCHEMA_GUARDRAIL_CONTEXTUAL_GROUNDING_FILTER), self - ) + serializer.write_struct(_SCHEMA_GUARDRAIL_CONTEXTUAL_GROUNDING_FILTER, self) def serialize_members(self, serializer: ShapeSerializer): - 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) + 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 + ) if self.detected is not None: - serializer.write_boolean(members[4], self.detected) + serializer.write_boolean( + _SCHEMA_GUARDRAIL_CONTEXTUAL_GROUNDING_FILTER.members["detected"], + self.detected, + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -3824,34 +4214,52 @@ 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(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: kwargs["type"] = GuardrailContextualGroundingFilterType( - de.read_string(members[0]) + de.read_string( + _SCHEMA_GUARDRAIL_CONTEXTUAL_GROUNDING_FILTER.members[ + "type" + ] + ) ) case 1: - kwargs["threshold"] = de.read_double(members[1]) + kwargs["threshold"] = de.read_double( + _SCHEMA_GUARDRAIL_CONTEXTUAL_GROUNDING_FILTER.members[ + "threshold" + ] + ) case 2: - kwargs["score"] = de.read_double(members[2]) + kwargs["score"] = de.read_double( + _SCHEMA_GUARDRAIL_CONTEXTUAL_GROUNDING_FILTER.members["score"] + ) case 3: kwargs["action"] = GuardrailContextualGroundingPolicyAction( - de.read_string(members[3]) + de.read_string( + _SCHEMA_GUARDRAIL_CONTEXTUAL_GROUNDING_FILTER.members[ + "action" + ] + ) ) case 4: - kwargs["detected"] = de.read_boolean(members[4]) + kwargs["detected"] = de.read_boolean( + _SCHEMA_GUARDRAIL_CONTEXTUAL_GROUNDING_FILTER.members[ + "detected" + ] + ) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct( + _SCHEMA_GUARDRAIL_CONTEXTUAL_GROUNDING_FILTER, consumer=_consumer + ) if "type" not in kwargs: kwargs["type"] = GuardrailContextualGroundingFilterType._corrected("") if "threshold" not in kwargs: @@ -3868,7 +4276,7 @@ def _serialize_guardrail_contextual_grounding_filters( schema: Schema, value: list[GuardrailContextualGroundingFilter], ) -> None: - member_schema = schema.members_by_index[0] + member_schema = schema.members["member"] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_struct(member_schema, e) @@ -3902,16 +4310,17 @@ class GuardrailContextualGroundingPolicyAssessment: def serialize(self, serializer: ShapeSerializer): serializer.write_struct( - hydrate(_SCHEMA_GUARDRAIL_CONTEXTUAL_GROUNDING_POLICY_ASSESSMENT), self + _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, members[0], self.filters + serializer, + _SCHEMA_GUARDRAIL_CONTEXTUAL_GROUNDING_POLICY_ASSESSMENT.members[ + "filters" + ], + self.filters, ) @classmethod @@ -3921,22 +4330,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_CONTEXTUAL_GROUNDING_POLICY_ASSESSMENT) - members = schema.members_by_index - def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: kwargs["filters"] = ( _deserialize_guardrail_contextual_grounding_filters( - de, members[0] + de, + _SCHEMA_GUARDRAIL_CONTEXTUAL_GROUNDING_POLICY_ASSESSMENT.members[ + "filters" + ], ) ) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct( + _SCHEMA_GUARDRAIL_CONTEXTUAL_GROUNDING_POLICY_ASSESSMENT, consumer=_consumer + ) return kwargs @@ -3954,15 +4366,18 @@ class GuardrailImageCoverage: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_GUARDRAIL_IMAGE_COVERAGE), self) + serializer.write_struct(_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(members[0], self.guarded) + serializer.write_integer( + _SCHEMA_GUARDRAIL_IMAGE_COVERAGE.members["guarded"], self.guarded + ) if self.total is not None: - serializer.write_integer(members[1], self.total) + serializer.write_integer( + _SCHEMA_GUARDRAIL_IMAGE_COVERAGE.members["total"], self.total + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -3971,21 +4386,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_IMAGE_COVERAGE) - members = schema.members_by_index - def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: - kwargs["guarded"] = de.read_integer(members[0]) + kwargs["guarded"] = de.read_integer( + _SCHEMA_GUARDRAIL_IMAGE_COVERAGE.members["guarded"] + ) case 1: - kwargs["total"] = de.read_integer(members[1]) + kwargs["total"] = de.read_integer( + _SCHEMA_GUARDRAIL_IMAGE_COVERAGE.members["total"] + ) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct(_SCHEMA_GUARDRAIL_IMAGE_COVERAGE, consumer=_consumer) return kwargs @@ -4000,17 +4417,19 @@ class GuardrailTextCharactersCoverage: """The total text characters by the guardrail coverage.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct( - hydrate(_SCHEMA_GUARDRAIL_TEXT_CHARACTERS_COVERAGE), self - ) + serializer.write_struct(_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(members[0], self.guarded) + serializer.write_integer( + _SCHEMA_GUARDRAIL_TEXT_CHARACTERS_COVERAGE.members["guarded"], + self.guarded, + ) if self.total is not None: - serializer.write_integer(members[1], self.total) + serializer.write_integer( + _SCHEMA_GUARDRAIL_TEXT_CHARACTERS_COVERAGE.members["total"], self.total + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -4019,21 +4438,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_TEXT_CHARACTERS_COVERAGE) - members = schema.members_by_index - def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: - kwargs["guarded"] = de.read_integer(members[0]) + kwargs["guarded"] = de.read_integer( + _SCHEMA_GUARDRAIL_TEXT_CHARACTERS_COVERAGE.members["guarded"] + ) case 1: - kwargs["total"] = de.read_integer(members[1]) + kwargs["total"] = de.read_integer( + _SCHEMA_GUARDRAIL_TEXT_CHARACTERS_COVERAGE.members["total"] + ) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct( + _SCHEMA_GUARDRAIL_TEXT_CHARACTERS_COVERAGE, consumer=_consumer + ) return kwargs @@ -4051,15 +4474,19 @@ class GuardrailCoverage: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_GUARDRAIL_COVERAGE), self) + serializer.write_struct(_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(members[0], self.text_characters) + serializer.write_struct( + _SCHEMA_GUARDRAIL_COVERAGE.members["textCharacters"], + self.text_characters, + ) if self.images is not None: - serializer.write_struct(members[1], self.images) + serializer.write_struct( + _SCHEMA_GUARDRAIL_COVERAGE.members["images"], self.images + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -4068,11 +4495,9 @@ 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(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: kwargs["text_characters"] = ( GuardrailTextCharactersCoverage.deserialize(de) @@ -4082,9 +4507,9 @@ def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: kwargs["images"] = GuardrailImageCoverage.deserialize(de) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct(_SCHEMA_GUARDRAIL_COVERAGE, consumer=_consumer) return kwargs @@ -4123,26 +4548,48 @@ class GuardrailUsage: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_GUARDRAIL_USAGE), self) + serializer.write_struct(_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( - members[4], self.sensitive_information_policy_free_units + _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, ) - serializer.write_integer(members[5], self.contextual_grounding_policy_units) if self.content_policy_image_units is not None: - serializer.write_integer(members[6], self.content_policy_image_units) + serializer.write_integer( + _SCHEMA_GUARDRAIL_USAGE.members["contentPolicyImageUnits"], + self.content_policy_image_units, + ) if self.automated_reasoning_policy_units is not None: - serializer.write_integer(members[7], self.automated_reasoning_policy_units) + serializer.write_integer( + _SCHEMA_GUARDRAIL_USAGE.members["automatedReasoningPolicyUnits"], + self.automated_reasoning_policy_units, + ) if self.automated_reasoning_policies is not None: - serializer.write_integer(members[8], self.automated_reasoning_policies) + serializer.write_integer( + _SCHEMA_GUARDRAIL_USAGE.members["automatedReasoningPolicies"], + self.automated_reasoning_policies, + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -4151,50 +4598,64 @@ 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(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: - kwargs["topic_policy_units"] = de.read_integer(members[0]) + kwargs["topic_policy_units"] = de.read_integer( + _SCHEMA_GUARDRAIL_USAGE.members["topicPolicyUnits"] + ) case 1: - kwargs["content_policy_units"] = de.read_integer(members[1]) + kwargs["content_policy_units"] = de.read_integer( + _SCHEMA_GUARDRAIL_USAGE.members["contentPolicyUnits"] + ) case 2: - kwargs["word_policy_units"] = de.read_integer(members[2]) + kwargs["word_policy_units"] = de.read_integer( + _SCHEMA_GUARDRAIL_USAGE.members["wordPolicyUnits"] + ) case 3: kwargs["sensitive_information_policy_units"] = de.read_integer( - members[3] + _SCHEMA_GUARDRAIL_USAGE.members[ + "sensitiveInformationPolicyUnits" + ] ) case 4: kwargs["sensitive_information_policy_free_units"] = de.read_integer( - members[4] + _SCHEMA_GUARDRAIL_USAGE.members[ + "sensitiveInformationPolicyFreeUnits" + ] ) case 5: kwargs["contextual_grounding_policy_units"] = de.read_integer( - members[5] + _SCHEMA_GUARDRAIL_USAGE.members[ + "contextualGroundingPolicyUnits" + ] ) case 6: - kwargs["content_policy_image_units"] = de.read_integer(members[6]) + kwargs["content_policy_image_units"] = de.read_integer( + _SCHEMA_GUARDRAIL_USAGE.members["contentPolicyImageUnits"] + ) case 7: kwargs["automated_reasoning_policy_units"] = de.read_integer( - members[7] + _SCHEMA_GUARDRAIL_USAGE.members["automatedReasoningPolicyUnits"] ) case 8: - kwargs["automated_reasoning_policies"] = de.read_integer(members[8]) + kwargs["automated_reasoning_policies"] = de.read_integer( + _SCHEMA_GUARDRAIL_USAGE.members["automatedReasoningPolicies"] + ) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct(_SCHEMA_GUARDRAIL_USAGE, consumer=_consumer) if "topic_policy_units" not in kwargs: kwargs["topic_policy_units"] = 0 if "content_policy_units" not in kwargs: @@ -4235,18 +4696,27 @@ class GuardrailInvocationMetrics: """The coverage details for the guardrail invocation metrics.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_GUARDRAIL_INVOCATION_METRICS), self) + serializer.write_struct(_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(members[0], self.guardrail_processing_latency) + serializer.write_long( + _SCHEMA_GUARDRAIL_INVOCATION_METRICS.members[ + "guardrailProcessingLatency" + ], + self.guardrail_processing_latency, + ) if self.usage is not None: - serializer.write_struct(members[1], self.usage) + serializer.write_struct( + _SCHEMA_GUARDRAIL_INVOCATION_METRICS.members["usage"], self.usage + ) if self.guardrail_coverage is not None: - serializer.write_struct(members[2], self.guardrail_coverage) + serializer.write_struct( + _SCHEMA_GUARDRAIL_INVOCATION_METRICS.members["guardrailCoverage"], + self.guardrail_coverage, + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -4255,13 +4725,15 @@ 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(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: - kwargs["guardrail_processing_latency"] = de.read_long(members[0]) + kwargs["guardrail_processing_latency"] = de.read_long( + _SCHEMA_GUARDRAIL_INVOCATION_METRICS.members[ + "guardrailProcessingLatency" + ] + ) case 1: kwargs["usage"] = GuardrailUsage.deserialize(de) @@ -4270,9 +4742,11 @@ def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: kwargs["guardrail_coverage"] = GuardrailCoverage.deserialize(de) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct( + _SCHEMA_GUARDRAIL_INVOCATION_METRICS, consumer=_consumer + ) return kwargs @@ -4339,15 +4813,22 @@ class GuardrailPiiEntityFilter: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_GUARDRAIL_PII_ENTITY_FILTER), self) + serializer.write_struct(_SCHEMA_GUARDRAIL_PII_ENTITY_FILTER, self) def serialize_members(self, serializer: ShapeSerializer): - 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) + 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 + ) if self.detected is not None: - serializer.write_boolean(members[3], self.detected) + serializer.write_boolean( + _SCHEMA_GUARDRAIL_PII_ENTITY_FILTER.members["detected"], self.detected + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -4356,29 +4837,39 @@ 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(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: - kwargs["match"] = de.read_string(members[0]) + kwargs["match"] = de.read_string( + _SCHEMA_GUARDRAIL_PII_ENTITY_FILTER.members["match"] + ) case 1: - kwargs["type"] = GuardrailPiiEntityType(de.read_string(members[1])) + kwargs["type"] = GuardrailPiiEntityType( + de.read_string( + _SCHEMA_GUARDRAIL_PII_ENTITY_FILTER.members["type"] + ) + ) case 2: kwargs["action"] = GuardrailSensitiveInformationPolicyAction( - de.read_string(members[2]) + de.read_string( + _SCHEMA_GUARDRAIL_PII_ENTITY_FILTER.members["action"] + ) ) case 3: - kwargs["detected"] = de.read_boolean(members[3]) + kwargs["detected"] = de.read_boolean( + _SCHEMA_GUARDRAIL_PII_ENTITY_FILTER.members["detected"] + ) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct( + _SCHEMA_GUARDRAIL_PII_ENTITY_FILTER, consumer=_consumer + ) if "match" not in kwargs: kwargs["match"] = "" if "type" not in kwargs: @@ -4391,7 +4882,7 @@ def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: def _serialize_guardrail_pii_entity_filter_list( serializer: ShapeSerializer, schema: Schema, value: list[GuardrailPiiEntityFilter] ) -> None: - member_schema = schema.members_by_index[0] + member_schema = schema.members["member"] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_struct(member_schema, e) @@ -4436,22 +4927,31 @@ class GuardrailRegexFilter: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_GUARDRAIL_REGEX_FILTER), self) + serializer.write_struct(_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(members[0], self.name) + serializer.write_string( + _SCHEMA_GUARDRAIL_REGEX_FILTER.members["name"], self.name + ) if self.match is not None: - serializer.write_string(members[1], self.match) + serializer.write_string( + _SCHEMA_GUARDRAIL_REGEX_FILTER.members["match"], self.match + ) if self.regex is not None: - serializer.write_string(members[2], self.regex) + serializer.write_string( + _SCHEMA_GUARDRAIL_REGEX_FILTER.members["regex"], self.regex + ) - serializer.write_string(members[3], self.action) + serializer.write_string( + _SCHEMA_GUARDRAIL_REGEX_FILTER.members["action"], self.action + ) if self.detected is not None: - serializer.write_boolean(members[4], self.detected) + serializer.write_boolean( + _SCHEMA_GUARDRAIL_REGEX_FILTER.members["detected"], self.detected + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -4460,32 +4960,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_REGEX_FILTER) - members = schema.members_by_index - def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: - kwargs["name"] = de.read_string(members[0]) + kwargs["name"] = de.read_string( + _SCHEMA_GUARDRAIL_REGEX_FILTER.members["name"] + ) case 1: - kwargs["match"] = de.read_string(members[1]) + kwargs["match"] = de.read_string( + _SCHEMA_GUARDRAIL_REGEX_FILTER.members["match"] + ) case 2: - kwargs["regex"] = de.read_string(members[2]) + kwargs["regex"] = de.read_string( + _SCHEMA_GUARDRAIL_REGEX_FILTER.members["regex"] + ) case 3: kwargs["action"] = GuardrailSensitiveInformationPolicyAction( - de.read_string(members[3]) + de.read_string(_SCHEMA_GUARDRAIL_REGEX_FILTER.members["action"]) ) case 4: - kwargs["detected"] = de.read_boolean(members[4]) + kwargs["detected"] = de.read_boolean( + _SCHEMA_GUARDRAIL_REGEX_FILTER.members["detected"] + ) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct(_SCHEMA_GUARDRAIL_REGEX_FILTER, consumer=_consumer) if "action" not in kwargs: kwargs["action"] = GuardrailSensitiveInformationPolicyAction._corrected("") return kwargs @@ -4494,7 +5000,7 @@ def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: def _serialize_guardrail_regex_filter_list( serializer: ShapeSerializer, schema: Schema, value: list[GuardrailRegexFilter] ) -> None: - member_schema = schema.members_by_index[0] + member_schema = schema.members["member"] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_struct(member_schema, e) @@ -4528,17 +5034,24 @@ class GuardrailSensitiveInformationPolicyAssessment: def serialize(self, serializer: ShapeSerializer): serializer.write_struct( - hydrate(_SCHEMA_GUARDRAIL_SENSITIVE_INFORMATION_POLICY_ASSESSMENT), self + _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, members[0], self.pii_entities + 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, ) - _serialize_guardrail_regex_filter_list(serializer, members[1], self.regexes) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -4547,25 +5060,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_SENSITIVE_INFORMATION_POLICY_ASSESSMENT) - members = schema.members_by_index - def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: kwargs["pii_entities"] = ( - _deserialize_guardrail_pii_entity_filter_list(de, members[0]) + _deserialize_guardrail_pii_entity_filter_list( + de, + _SCHEMA_GUARDRAIL_SENSITIVE_INFORMATION_POLICY_ASSESSMENT.members[ + "piiEntities" + ], + ) ) case 1: kwargs["regexes"] = _deserialize_guardrail_regex_filter_list( - de, members[1] + de, + _SCHEMA_GUARDRAIL_SENSITIVE_INFORMATION_POLICY_ASSESSMENT.members[ + "regexes" + ], ) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct( + _SCHEMA_GUARDRAIL_SENSITIVE_INFORMATION_POLICY_ASSESSMENT, + consumer=_consumer, + ) if "pii_entities" not in kwargs: kwargs["pii_entities"] = [] if "regexes" not in kwargs: @@ -4605,15 +5127,16 @@ class GuardrailTopic: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_GUARDRAIL_TOPIC), self) + serializer.write_struct(_SCHEMA_GUARDRAIL_TOPIC, self) def serialize_members(self, serializer: ShapeSerializer): - 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) + 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) if self.detected is not None: - serializer.write_boolean(members[3], self.detected) + serializer.write_boolean( + _SCHEMA_GUARDRAIL_TOPIC.members["detected"], self.detected + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -4622,29 +5145,33 @@ 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(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: - kwargs["name"] = de.read_string(members[0]) + kwargs["name"] = de.read_string( + _SCHEMA_GUARDRAIL_TOPIC.members["name"] + ) case 1: - kwargs["type"] = GuardrailTopicType(de.read_string(members[1])) + kwargs["type"] = GuardrailTopicType( + de.read_string(_SCHEMA_GUARDRAIL_TOPIC.members["type"]) + ) case 2: kwargs["action"] = GuardrailTopicPolicyAction( - de.read_string(members[2]) + de.read_string(_SCHEMA_GUARDRAIL_TOPIC.members["action"]) ) case 3: - kwargs["detected"] = de.read_boolean(members[3]) + kwargs["detected"] = de.read_boolean( + _SCHEMA_GUARDRAIL_TOPIC.members["detected"] + ) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct(_SCHEMA_GUARDRAIL_TOPIC, consumer=_consumer) if "name" not in kwargs: kwargs["name"] = "" if "type" not in kwargs: @@ -4657,7 +5184,7 @@ def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: def _serialize_guardrail_topic_list( serializer: ShapeSerializer, schema: Schema, value: list[GuardrailTopic] ) -> None: - member_schema = schema.members_by_index[0] + member_schema = schema.members["member"] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_struct(member_schema, e) @@ -4687,13 +5214,14 @@ class GuardrailTopicPolicyAssessment: """The topics in the assessment.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct( - hydrate(_SCHEMA_GUARDRAIL_TOPIC_POLICY_ASSESSMENT), self - ) + serializer.write_struct(_SCHEMA_GUARDRAIL_TOPIC_POLICY_ASSESSMENT, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_GUARDRAIL_TOPIC_POLICY_ASSESSMENT).members_by_index - _serialize_guardrail_topic_list(serializer, members[0], self.topics) + _serialize_guardrail_topic_list( + serializer, + _SCHEMA_GUARDRAIL_TOPIC_POLICY_ASSESSMENT.members["topics"], + self.topics, + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -4702,18 +5230,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_TOPIC_POLICY_ASSESSMENT) - members = schema.members_by_index - def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: - kwargs["topics"] = _deserialize_guardrail_topic_list(de, members[0]) + kwargs["topics"] = _deserialize_guardrail_topic_list( + de, _SCHEMA_GUARDRAIL_TOPIC_POLICY_ASSESSMENT.members["topics"] + ) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct( + _SCHEMA_GUARDRAIL_TOPIC_POLICY_ASSESSMENT, consumer=_consumer + ) if "topics" not in kwargs: kwargs["topics"] = [] return kwargs @@ -4741,14 +5271,19 @@ class GuardrailCustomWord: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_GUARDRAIL_CUSTOM_WORD), self) + serializer.write_struct(_SCHEMA_GUARDRAIL_CUSTOM_WORD, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_GUARDRAIL_CUSTOM_WORD).members_by_index - serializer.write_string(members[0], self.match) - serializer.write_string(members[1], self.action) + serializer.write_string( + _SCHEMA_GUARDRAIL_CUSTOM_WORD.members["match"], self.match + ) + serializer.write_string( + _SCHEMA_GUARDRAIL_CUSTOM_WORD.members["action"], self.action + ) if self.detected is not None: - serializer.write_boolean(members[2], self.detected) + serializer.write_boolean( + _SCHEMA_GUARDRAIL_CUSTOM_WORD.members["detected"], self.detected + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -4757,26 +5292,28 @@ 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(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: - kwargs["match"] = de.read_string(members[0]) + kwargs["match"] = de.read_string( + _SCHEMA_GUARDRAIL_CUSTOM_WORD.members["match"] + ) case 1: kwargs["action"] = GuardrailWordPolicyAction( - de.read_string(members[1]) + de.read_string(_SCHEMA_GUARDRAIL_CUSTOM_WORD.members["action"]) ) case 2: - kwargs["detected"] = de.read_boolean(members[2]) + kwargs["detected"] = de.read_boolean( + _SCHEMA_GUARDRAIL_CUSTOM_WORD.members["detected"] + ) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct(_SCHEMA_GUARDRAIL_CUSTOM_WORD, consumer=_consumer) if "match" not in kwargs: kwargs["match"] = "" if "action" not in kwargs: @@ -4787,7 +5324,7 @@ def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: def _serialize_guardrail_custom_word_list( serializer: ShapeSerializer, schema: Schema, value: list[GuardrailCustomWord] ) -> None: - member_schema = schema.members_by_index[0] + member_schema = schema.members["member"] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_struct(member_schema, e) @@ -4833,15 +5370,22 @@ class GuardrailManagedWord: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_GUARDRAIL_MANAGED_WORD), self) + serializer.write_struct(_SCHEMA_GUARDRAIL_MANAGED_WORD, self) def serialize_members(self, serializer: ShapeSerializer): - 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) + 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 + ) if self.detected is not None: - serializer.write_boolean(members[3], self.detected) + serializer.write_boolean( + _SCHEMA_GUARDRAIL_MANAGED_WORD.members["detected"], self.detected + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -4850,31 +5394,33 @@ 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(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: - kwargs["match"] = de.read_string(members[0]) + kwargs["match"] = de.read_string( + _SCHEMA_GUARDRAIL_MANAGED_WORD.members["match"] + ) case 1: kwargs["type"] = GuardrailManagedWordType( - de.read_string(members[1]) + de.read_string(_SCHEMA_GUARDRAIL_MANAGED_WORD.members["type"]) ) case 2: kwargs["action"] = GuardrailWordPolicyAction( - de.read_string(members[2]) + de.read_string(_SCHEMA_GUARDRAIL_MANAGED_WORD.members["action"]) ) case 3: - kwargs["detected"] = de.read_boolean(members[3]) + kwargs["detected"] = de.read_boolean( + _SCHEMA_GUARDRAIL_MANAGED_WORD.members["detected"] + ) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct(_SCHEMA_GUARDRAIL_MANAGED_WORD, consumer=_consumer) if "match" not in kwargs: kwargs["match"] = "" if "type" not in kwargs: @@ -4887,7 +5433,7 @@ def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: def _serialize_guardrail_managed_word_list( serializer: ShapeSerializer, schema: Schema, value: list[GuardrailManagedWord] ) -> None: - member_schema = schema.members_by_index[0] + member_schema = schema.members["member"] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_struct(member_schema, e) @@ -4920,13 +5466,18 @@ class GuardrailWordPolicyAssessment: """Managed word lists in the assessment.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_GUARDRAIL_WORD_POLICY_ASSESSMENT), self) + serializer.write_struct(_SCHEMA_GUARDRAIL_WORD_POLICY_ASSESSMENT, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_GUARDRAIL_WORD_POLICY_ASSESSMENT).members_by_index - _serialize_guardrail_custom_word_list(serializer, members[0], self.custom_words) + _serialize_guardrail_custom_word_list( + serializer, + _SCHEMA_GUARDRAIL_WORD_POLICY_ASSESSMENT.members["customWords"], + self.custom_words, + ) _serialize_guardrail_managed_word_list( - serializer, members[1], self.managed_word_lists + serializer, + _SCHEMA_GUARDRAIL_WORD_POLICY_ASSESSMENT.members["managedWordLists"], + self.managed_word_lists, ) @classmethod @@ -4936,25 +5487,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_WORD_POLICY_ASSESSMENT) - members = schema.members_by_index - def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: kwargs["custom_words"] = _deserialize_guardrail_custom_word_list( - de, members[0] + de, + _SCHEMA_GUARDRAIL_WORD_POLICY_ASSESSMENT.members["customWords"], ) case 1: kwargs["managed_word_lists"] = ( - _deserialize_guardrail_managed_word_list(de, members[1]) + _deserialize_guardrail_managed_word_list( + de, + _SCHEMA_GUARDRAIL_WORD_POLICY_ASSESSMENT.members[ + "managedWordLists" + ], + ) ) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct( + _SCHEMA_GUARDRAIL_WORD_POLICY_ASSESSMENT, consumer=_consumer + ) if "custom_words" not in kwargs: kwargs["custom_words"] = [] if "managed_word_lists" not in kwargs: @@ -5007,33 +5564,54 @@ class GuardrailAssessment: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_GUARDRAIL_ASSESSMENT), self) + serializer.write_struct(_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(members[0], self.topic_policy) + serializer.write_struct( + _SCHEMA_GUARDRAIL_ASSESSMENT.members["topicPolicy"], self.topic_policy + ) if self.content_policy is not None: - serializer.write_struct(members[1], self.content_policy) + serializer.write_struct( + _SCHEMA_GUARDRAIL_ASSESSMENT.members["contentPolicy"], + self.content_policy, + ) if self.word_policy is not None: - serializer.write_struct(members[2], self.word_policy) + serializer.write_struct( + _SCHEMA_GUARDRAIL_ASSESSMENT.members["wordPolicy"], self.word_policy + ) if self.sensitive_information_policy is not None: - serializer.write_struct(members[3], self.sensitive_information_policy) + serializer.write_struct( + _SCHEMA_GUARDRAIL_ASSESSMENT.members["sensitiveInformationPolicy"], + self.sensitive_information_policy, + ) if self.contextual_grounding_policy is not None: - serializer.write_struct(members[4], self.contextual_grounding_policy) + serializer.write_struct( + _SCHEMA_GUARDRAIL_ASSESSMENT.members["contextualGroundingPolicy"], + self.contextual_grounding_policy, + ) if self.automated_reasoning_policy is not None: - serializer.write_struct(members[5], self.automated_reasoning_policy) + serializer.write_struct( + _SCHEMA_GUARDRAIL_ASSESSMENT.members["automatedReasoningPolicy"], + self.automated_reasoning_policy, + ) if self.invocation_metrics is not None: - serializer.write_struct(members[6], self.invocation_metrics) + serializer.write_struct( + _SCHEMA_GUARDRAIL_ASSESSMENT.members["invocationMetrics"], + self.invocation_metrics, + ) if self.applied_guardrail_details is not None: - serializer.write_struct(members[7], self.applied_guardrail_details) + serializer.write_struct( + _SCHEMA_GUARDRAIL_ASSESSMENT.members["appliedGuardrailDetails"], + self.applied_guardrail_details, + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -5042,11 +5620,9 @@ 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(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: kwargs["topic_policy"] = GuardrailTopicPolicyAssessment.deserialize( de @@ -5088,16 +5664,16 @@ def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: ) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct(_SCHEMA_GUARDRAIL_ASSESSMENT, consumer=_consumer) return kwargs def _serialize_guardrail_assessment_list( serializer: ShapeSerializer, schema: Schema, value: list[GuardrailAssessment] ) -> None: - member_schema = schema.members_by_index[0] + member_schema = schema.members["member"] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_struct(member_schema, e) @@ -5127,12 +5703,13 @@ class GuardrailOutputContent: """The specific text for the output content produced by the guardrail.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_GUARDRAIL_OUTPUT_CONTENT), self) + serializer.write_struct(_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(members[0], self.text) + serializer.write_string( + _SCHEMA_GUARDRAIL_OUTPUT_CONTENT.members["text"], self.text + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -5141,25 +5718,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(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: - kwargs["text"] = de.read_string(members[0]) + kwargs["text"] = de.read_string( + _SCHEMA_GUARDRAIL_OUTPUT_CONTENT.members["text"] + ) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct(_SCHEMA_GUARDRAIL_OUTPUT_CONTENT, consumer=_consumer) return kwargs def _serialize_guardrail_output_content_list( serializer: ShapeSerializer, schema: Schema, value: list[GuardrailOutputContent] ) -> None: - member_schema = schema.members_by_index[0] + member_schema = schema.members["member"] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_struct(member_schema, e) @@ -5214,19 +5791,34 @@ class ApplyGuardrailOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_APPLY_GUARDRAIL_OUTPUT), self) + serializer.write_struct(_SCHEMA_APPLY_GUARDRAIL_OUTPUT, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_APPLY_GUARDRAIL_OUTPUT).members_by_index - serializer.write_struct(members[0], self.usage) - serializer.write_string(members[1], self.action) + serializer.write_struct( + _SCHEMA_APPLY_GUARDRAIL_OUTPUT.members["usage"], self.usage + ) + serializer.write_string( + _SCHEMA_APPLY_GUARDRAIL_OUTPUT.members["action"], self.action + ) if self.action_reason is not None: - serializer.write_string(members[2], self.action_reason) + serializer.write_string( + _SCHEMA_APPLY_GUARDRAIL_OUTPUT.members["actionReason"], + self.action_reason, + ) - _serialize_guardrail_output_content_list(serializer, members[3], self.outputs) - _serialize_guardrail_assessment_list(serializer, members[4], self.assessments) + _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, + ) if self.guardrail_coverage is not None: - serializer.write_struct(members[5], self.guardrail_coverage) + serializer.write_struct( + _SCHEMA_APPLY_GUARDRAIL_OUTPUT.members["guardrailCoverage"], + self.guardrail_coverage, + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -5235,37 +5827,39 @@ 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(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: kwargs["usage"] = GuardrailUsage.deserialize(de) case 1: - kwargs["action"] = GuardrailAction(de.read_string(members[1])) + kwargs["action"] = GuardrailAction( + de.read_string(_SCHEMA_APPLY_GUARDRAIL_OUTPUT.members["action"]) + ) case 2: - kwargs["action_reason"] = de.read_string(members[2]) + kwargs["action_reason"] = de.read_string( + _SCHEMA_APPLY_GUARDRAIL_OUTPUT.members["actionReason"] + ) case 3: kwargs["outputs"] = _deserialize_guardrail_output_content_list( - de, members[3] + de, _SCHEMA_APPLY_GUARDRAIL_OUTPUT.members["outputs"] ) case 4: kwargs["assessments"] = _deserialize_guardrail_assessment_list( - de, members[4] + de, _SCHEMA_APPLY_GUARDRAIL_OUTPUT.members["assessments"] ) case 5: kwargs["guardrail_coverage"] = GuardrailCoverage.deserialize(de) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct(_SCHEMA_APPLY_GUARDRAIL_OUTPUT, consumer=_consumer) if "usage" not in kwargs: kwargs["usage"] = GuardrailUsage._smithy_default() if "action" not in kwargs: @@ -5280,7 +5874,9 @@ def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: APPLY_GUARDRAIL = APIOperation( input=ApplyGuardrailInput, output=ApplyGuardrailOutput, - static_schema=_SCHEMA_APPLY_GUARDRAIL, + schema=_SCHEMA_APPLY_GUARDRAIL, + input_schema=_SCHEMA_APPLY_GUARDRAIL_INPUT, + output_schema=_SCHEMA_APPLY_GUARDRAIL_OUTPUT, error_registry=TypeRegistry( { ShapeID( @@ -5310,6 +5906,15 @@ def _consumer(member_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, + ], ) @@ -5332,14 +5937,14 @@ class GuardrailChecksContentFilterCategoryConfig: def serialize(self, serializer: ShapeSerializer): serializer.write_struct( - hydrate(_SCHEMA_GUARDRAIL_CHECKS_CONTENT_FILTER_CATEGORY_CONFIG), self + _SCHEMA_GUARDRAIL_CHECKS_CONTENT_FILTER_CATEGORY_CONFIG, self ) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate( - _SCHEMA_GUARDRAIL_CHECKS_CONTENT_FILTER_CATEGORY_CONFIG - ).members_by_index - serializer.write_string(members[0], self.category) + serializer.write_string( + _SCHEMA_GUARDRAIL_CHECKS_CONTENT_FILTER_CATEGORY_CONFIG.members["category"], + self.category, + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -5348,20 +5953,24 @@ 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(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: kwargs["category"] = GuardrailChecksContentFilterCategory( - de.read_string(members[0]) + de.read_string( + _SCHEMA_GUARDRAIL_CHECKS_CONTENT_FILTER_CATEGORY_CONFIG.members[ + "category" + ] + ) ) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct( + _SCHEMA_GUARDRAIL_CHECKS_CONTENT_FILTER_CATEGORY_CONFIG, consumer=_consumer + ) if "category" not in kwargs: kwargs["category"] = GuardrailChecksContentFilterCategory._corrected("") return kwargs @@ -5372,7 +5981,7 @@ def _serialize_guardrail_checks_content_filter_category_config_list( schema: Schema, value: list[GuardrailChecksContentFilterCategoryConfig], ) -> None: - member_schema = schema.members_by_index[0] + member_schema = schema.members["member"] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_struct(member_schema, e) @@ -5405,16 +6014,13 @@ class GuardrailChecksContentFilterConfig: """The content filter categories to evaluate.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct( - hydrate(_SCHEMA_GUARDRAIL_CHECKS_CONTENT_FILTER_CONFIG), self - ) + serializer.write_struct(_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, members[0], self.categories + serializer, + _SCHEMA_GUARDRAIL_CHECKS_CONTENT_FILTER_CONFIG.members["categories"], + self.categories, ) @classmethod @@ -5424,22 +6030,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_CONTENT_FILTER_CONFIG) - members = schema.members_by_index - def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: kwargs["categories"] = ( _deserialize_guardrail_checks_content_filter_category_config_list( - de, members[0] + de, + _SCHEMA_GUARDRAIL_CHECKS_CONTENT_FILTER_CONFIG.members[ + "categories" + ], ) ) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct( + _SCHEMA_GUARDRAIL_CHECKS_CONTENT_FILTER_CONFIG, consumer=_consumer + ) if "categories" not in kwargs: kwargs["categories"] = [] return kwargs @@ -5462,14 +6071,14 @@ class GuardrailChecksPromptAttackCategoryConfig: def serialize(self, serializer: ShapeSerializer): serializer.write_struct( - hydrate(_SCHEMA_GUARDRAIL_CHECKS_PROMPT_ATTACK_CATEGORY_CONFIG), self + _SCHEMA_GUARDRAIL_CHECKS_PROMPT_ATTACK_CATEGORY_CONFIG, self ) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate( - _SCHEMA_GUARDRAIL_CHECKS_PROMPT_ATTACK_CATEGORY_CONFIG - ).members_by_index - serializer.write_string(members[0], self.category) + serializer.write_string( + _SCHEMA_GUARDRAIL_CHECKS_PROMPT_ATTACK_CATEGORY_CONFIG.members["category"], + self.category, + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -5478,20 +6087,24 @@ 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(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: kwargs["category"] = GuardrailChecksPromptAttackCategory( - de.read_string(members[0]) + de.read_string( + _SCHEMA_GUARDRAIL_CHECKS_PROMPT_ATTACK_CATEGORY_CONFIG.members[ + "category" + ] + ) ) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct( + _SCHEMA_GUARDRAIL_CHECKS_PROMPT_ATTACK_CATEGORY_CONFIG, consumer=_consumer + ) if "category" not in kwargs: kwargs["category"] = GuardrailChecksPromptAttackCategory._corrected("") return kwargs @@ -5502,7 +6115,7 @@ def _serialize_guardrail_checks_prompt_attack_category_config_list( schema: Schema, value: list[GuardrailChecksPromptAttackCategoryConfig], ) -> None: - member_schema = schema.members_by_index[0] + member_schema = schema.members["member"] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_struct(member_schema, e) @@ -5535,16 +6148,13 @@ class GuardrailChecksPromptAttackConfig: """The prompt attack categories to evaluate.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct( - hydrate(_SCHEMA_GUARDRAIL_CHECKS_PROMPT_ATTACK_CONFIG), self - ) + serializer.write_struct(_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, members[0], self.categories + serializer, + _SCHEMA_GUARDRAIL_CHECKS_PROMPT_ATTACK_CONFIG.members["categories"], + self.categories, ) @classmethod @@ -5554,22 +6164,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_PROMPT_ATTACK_CONFIG) - members = schema.members_by_index - def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: kwargs["categories"] = ( _deserialize_guardrail_checks_prompt_attack_category_config_list( - de, members[0] + de, + _SCHEMA_GUARDRAIL_CHECKS_PROMPT_ATTACK_CONFIG.members[ + "categories" + ], ) ) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct( + _SCHEMA_GUARDRAIL_CHECKS_PROMPT_ATTACK_CONFIG, consumer=_consumer + ) if "categories" not in kwargs: kwargs["categories"] = [] return kwargs @@ -5623,14 +6236,16 @@ class GuardrailChecksSensitiveInformationEntityConfig: def serialize(self, serializer: ShapeSerializer): serializer.write_struct( - hydrate(_SCHEMA_GUARDRAIL_CHECKS_SENSITIVE_INFORMATION_ENTITY_CONFIG), self + _SCHEMA_GUARDRAIL_CHECKS_SENSITIVE_INFORMATION_ENTITY_CONFIG, self ) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate( - _SCHEMA_GUARDRAIL_CHECKS_SENSITIVE_INFORMATION_ENTITY_CONFIG - ).members_by_index - serializer.write_string(members[0], self.type) + serializer.write_string( + _SCHEMA_GUARDRAIL_CHECKS_SENSITIVE_INFORMATION_ENTITY_CONFIG.members[ + "type" + ], + self.type, + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -5639,20 +6254,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_ENTITY_CONFIG) - members = schema.members_by_index - def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: kwargs["type"] = GuardrailChecksSensitiveInformationEntityType( - de.read_string(members[0]) + de.read_string( + _SCHEMA_GUARDRAIL_CHECKS_SENSITIVE_INFORMATION_ENTITY_CONFIG.members[ + "type" + ] + ) ) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct( + _SCHEMA_GUARDRAIL_CHECKS_SENSITIVE_INFORMATION_ENTITY_CONFIG, + consumer=_consumer, + ) if "type" not in kwargs: kwargs["type"] = GuardrailChecksSensitiveInformationEntityType._corrected( "" @@ -5665,7 +6285,7 @@ def _serialize_guardrail_checks_sensitive_information_entity_config_list( schema: Schema, value: list[GuardrailChecksSensitiveInformationEntityConfig], ) -> None: - member_schema = schema.members_by_index[0] + member_schema = schema.members["member"] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_struct(member_schema, e) @@ -5701,15 +6321,14 @@ class GuardrailChecksSensitiveInformationConfig: def serialize(self, serializer: ShapeSerializer): serializer.write_struct( - hydrate(_SCHEMA_GUARDRAIL_CHECKS_SENSITIVE_INFORMATION_CONFIG), self + _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, members[0], self.entities + serializer, + _SCHEMA_GUARDRAIL_CHECKS_SENSITIVE_INFORMATION_CONFIG.members["entities"], + self.entities, ) @classmethod @@ -5719,22 +6338,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_CONFIG) - members = schema.members_by_index - def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: kwargs["entities"] = ( _deserialize_guardrail_checks_sensitive_information_entity_config_list( - de, members[0] + de, + _SCHEMA_GUARDRAIL_CHECKS_SENSITIVE_INFORMATION_CONFIG.members[ + "entities" + ], ) ) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct( + _SCHEMA_GUARDRAIL_CHECKS_SENSITIVE_INFORMATION_CONFIG, consumer=_consumer + ) if "entities" not in kwargs: kwargs["entities"] = [] return kwargs @@ -5757,18 +6379,26 @@ class GuardrailChecksConfig: """The sensitive information check configuration.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_GUARDRAIL_CHECKS_CONFIG), self) + serializer.write_struct(_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(members[0], self.content_filter) + serializer.write_struct( + _SCHEMA_GUARDRAIL_CHECKS_CONFIG.members["contentFilter"], + self.content_filter, + ) if self.prompt_attack is not None: - serializer.write_struct(members[1], self.prompt_attack) + serializer.write_struct( + _SCHEMA_GUARDRAIL_CHECKS_CONFIG.members["promptAttack"], + self.prompt_attack, + ) if self.sensitive_information is not None: - serializer.write_struct(members[2], self.sensitive_information) + serializer.write_struct( + _SCHEMA_GUARDRAIL_CHECKS_CONFIG.members["sensitiveInformation"], + self.sensitive_information, + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -5777,11 +6407,9 @@ 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(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: kwargs["content_filter"] = ( GuardrailChecksContentFilterConfig.deserialize(de) @@ -5798,9 +6426,9 @@ def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: ) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct(_SCHEMA_GUARDRAIL_CHECKS_CONFIG, consumer=_consumer) return kwargs @@ -5811,16 +6439,20 @@ class GuardrailChecksContentBlockText: value: str def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_GUARDRAIL_CHECKS_CONTENT_BLOCK), self) + serializer.write_struct(_SCHEMA_GUARDRAIL_CHECKS_CONTENT_BLOCK, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_GUARDRAIL_CHECKS_CONTENT_BLOCK).members_by_index - serializer.write_string(members[0], self.value) + serializer.write_string( + _SCHEMA_GUARDRAIL_CHECKS_CONTENT_BLOCK.members["text"], self.value + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: - members = hydrate(_SCHEMA_GUARDRAIL_CHECKS_CONTENT_BLOCK).members_by_index - return cls(value=deserializer.read_string(members[0])) + return cls( + value=deserializer.read_string( + _SCHEMA_GUARDRAIL_CHECKS_CONTENT_BLOCK.members["text"] + ) + ) @dataclass @@ -5860,9 +6492,7 @@ def deserialize( self, deserializer: ShapeDeserializer ) -> GuardrailChecksContentBlock: self._result = None - deserializer.read_struct( - hydrate(_SCHEMA_GUARDRAIL_CHECKS_CONTENT_BLOCK), self._consumer - ) + deserializer.read_struct(_SCHEMA_GUARDRAIL_CHECKS_CONTENT_BLOCK, self._consumer) if self._result is None: raise SerializationError( @@ -5894,7 +6524,7 @@ def _serialize_guardrail_checks_content_block_list( schema: Schema, value: list[GuardrailChecksContentBlock], ) -> None: - member_schema = schema.members_by_index[0] + member_schema = schema.members["member"] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_struct(member_schema, e) @@ -5938,13 +6568,16 @@ class GuardrailChecksMessage: """The content blocks for the message.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_GUARDRAIL_CHECKS_MESSAGE), self) + serializer.write_struct(_SCHEMA_GUARDRAIL_CHECKS_MESSAGE, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_GUARDRAIL_CHECKS_MESSAGE).members_by_index - serializer.write_string(members[0], self.role) + serializer.write_string( + _SCHEMA_GUARDRAIL_CHECKS_MESSAGE.members["role"], self.role + ) _serialize_guardrail_checks_content_block_list( - serializer, members[1], self.content + serializer, + _SCHEMA_GUARDRAIL_CHECKS_MESSAGE.members["content"], + self.content, ) @classmethod @@ -5954,23 +6587,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_MESSAGE) - members = schema.members_by_index - def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: - kwargs["role"] = GuardrailChecksRole(de.read_string(members[0])) + kwargs["role"] = GuardrailChecksRole( + de.read_string(_SCHEMA_GUARDRAIL_CHECKS_MESSAGE.members["role"]) + ) case 1: kwargs["content"] = ( - _deserialize_guardrail_checks_content_block_list(de, members[1]) + _deserialize_guardrail_checks_content_block_list( + de, _SCHEMA_GUARDRAIL_CHECKS_MESSAGE.members["content"] + ) ) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct(_SCHEMA_GUARDRAIL_CHECKS_MESSAGE, consumer=_consumer) if "role" not in kwargs: kwargs["role"] = GuardrailChecksRole._corrected("") if "content" not in kwargs: @@ -5981,7 +6616,7 @@ def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: def _serialize_guardrail_checks_message_list( serializer: ShapeSerializer, schema: Schema, value: list[GuardrailChecksMessage] ) -> None: - member_schema = schema.members_by_index[0] + member_schema = schema.members["member"] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_struct(member_schema, e) @@ -6020,17 +6655,20 @@ class InvokeGuardrailChecksInput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_INVOKE_GUARDRAIL_CHECKS_INPUT), self) + serializer.write_struct(_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, members[0], self.messages + serializer, + _SCHEMA_INVOKE_GUARDRAIL_CHECKS_INPUT.members["messages"], + self.messages, ) if self.checks is not None: - serializer.write_struct(members[1], self.checks) + serializer.write_struct( + _SCHEMA_INVOKE_GUARDRAIL_CHECKS_INPUT.members["checks"], self.checks + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -6039,23 +6677,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(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: kwargs["messages"] = _deserialize_guardrail_checks_message_list( - de, members[0] + de, _SCHEMA_INVOKE_GUARDRAIL_CHECKS_INPUT.members["messages"] ) case 1: kwargs["checks"] = GuardrailChecksConfig.deserialize(de) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct( + _SCHEMA_INVOKE_GUARDRAIL_CHECKS_INPUT, consumer=_consumer + ) return kwargs @@ -6074,15 +6712,20 @@ class GuardrailChecksContentFilterResultEntry: def serialize(self, serializer: ShapeSerializer): serializer.write_struct( - hydrate(_SCHEMA_GUARDRAIL_CHECKS_CONTENT_FILTER_RESULT_ENTRY), self + _SCHEMA_GUARDRAIL_CHECKS_CONTENT_FILTER_RESULT_ENTRY, self ) def serialize_members(self, serializer: ShapeSerializer): - 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) + 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, + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -6091,23 +6734,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_CHECKS_CONTENT_FILTER_RESULT_ENTRY) - members = schema.members_by_index - def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: kwargs["category"] = GuardrailChecksContentFilterCategory( - de.read_string(members[0]) + de.read_string( + _SCHEMA_GUARDRAIL_CHECKS_CONTENT_FILTER_RESULT_ENTRY.members[ + "category" + ] + ) ) case 1: - kwargs["severity_score"] = de.read_double(members[1]) + kwargs["severity_score"] = de.read_double( + _SCHEMA_GUARDRAIL_CHECKS_CONTENT_FILTER_RESULT_ENTRY.members[ + "severityScore" + ] + ) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct( + _SCHEMA_GUARDRAIL_CHECKS_CONTENT_FILTER_RESULT_ENTRY, consumer=_consumer + ) if "category" not in kwargs: kwargs["category"] = GuardrailChecksContentFilterCategory._corrected("") if "severity_score" not in kwargs: @@ -6120,7 +6771,7 @@ def _serialize_guardrail_checks_content_filter_result_list( schema: Schema, value: list[GuardrailChecksContentFilterResultEntry], ) -> None: - member_schema = schema.members_by_index[0] + member_schema = schema.members["member"] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_struct(member_schema, e) @@ -6150,16 +6801,13 @@ class GuardrailChecksContentFilterResult: """The per-category content filter results.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct( - hydrate(_SCHEMA_GUARDRAIL_CHECKS_CONTENT_FILTER_RESULT), self - ) + serializer.write_struct(_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, members[0], self.results + serializer, + _SCHEMA_GUARDRAIL_CHECKS_CONTENT_FILTER_RESULT.members["results"], + self.results, ) @classmethod @@ -6169,22 +6817,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_CONTENT_FILTER_RESULT) - members = schema.members_by_index - def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: kwargs["results"] = ( _deserialize_guardrail_checks_content_filter_result_list( - de, members[0] + de, + _SCHEMA_GUARDRAIL_CHECKS_CONTENT_FILTER_RESULT.members[ + "results" + ], ) ) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct( + _SCHEMA_GUARDRAIL_CHECKS_CONTENT_FILTER_RESULT, consumer=_consumer + ) if "results" not in kwargs: kwargs["results"] = [] return kwargs @@ -6205,15 +6856,20 @@ class GuardrailChecksPromptAttackResultEntry: def serialize(self, serializer: ShapeSerializer): serializer.write_struct( - hydrate(_SCHEMA_GUARDRAIL_CHECKS_PROMPT_ATTACK_RESULT_ENTRY), self + _SCHEMA_GUARDRAIL_CHECKS_PROMPT_ATTACK_RESULT_ENTRY, self ) def serialize_members(self, serializer: ShapeSerializer): - 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) + 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, + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -6222,23 +6878,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_CHECKS_PROMPT_ATTACK_RESULT_ENTRY) - members = schema.members_by_index - def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: kwargs["category"] = GuardrailChecksPromptAttackCategory( - de.read_string(members[0]) + de.read_string( + _SCHEMA_GUARDRAIL_CHECKS_PROMPT_ATTACK_RESULT_ENTRY.members[ + "category" + ] + ) ) case 1: - kwargs["severity_score"] = de.read_double(members[1]) + kwargs["severity_score"] = de.read_double( + _SCHEMA_GUARDRAIL_CHECKS_PROMPT_ATTACK_RESULT_ENTRY.members[ + "severityScore" + ] + ) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct( + _SCHEMA_GUARDRAIL_CHECKS_PROMPT_ATTACK_RESULT_ENTRY, consumer=_consumer + ) if "category" not in kwargs: kwargs["category"] = GuardrailChecksPromptAttackCategory._corrected("") if "severity_score" not in kwargs: @@ -6251,7 +6915,7 @@ def _serialize_guardrail_checks_prompt_attack_result_list( schema: Schema, value: list[GuardrailChecksPromptAttackResultEntry], ) -> None: - member_schema = schema.members_by_index[0] + member_schema = schema.members["member"] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_struct(member_schema, e) @@ -6281,16 +6945,13 @@ class GuardrailChecksPromptAttackResult: """The per-category prompt attack results.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct( - hydrate(_SCHEMA_GUARDRAIL_CHECKS_PROMPT_ATTACK_RESULT), self - ) + serializer.write_struct(_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, members[0], self.results + serializer, + _SCHEMA_GUARDRAIL_CHECKS_PROMPT_ATTACK_RESULT.members["results"], + self.results, ) @classmethod @@ -6300,22 +6961,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_PROMPT_ATTACK_RESULT) - members = schema.members_by_index - def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: kwargs["results"] = ( _deserialize_guardrail_checks_prompt_attack_result_list( - de, members[0] + de, + _SCHEMA_GUARDRAIL_CHECKS_PROMPT_ATTACK_RESULT.members[ + "results" + ], ) ) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct( + _SCHEMA_GUARDRAIL_CHECKS_PROMPT_ATTACK_RESULT, consumer=_consumer + ) if "results" not in kwargs: kwargs["results"] = [] return kwargs @@ -6363,19 +7027,44 @@ class GuardrailChecksSensitiveInformationResultEntry: def serialize(self, serializer: ShapeSerializer): serializer.write_struct( - hydrate(_SCHEMA_GUARDRAIL_CHECKS_SENSITIVE_INFORMATION_RESULT_ENTRY), self + _SCHEMA_GUARDRAIL_CHECKS_SENSITIVE_INFORMATION_RESULT_ENTRY, self ) def serialize_members(self, serializer: ShapeSerializer): - 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) + 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, + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -6384,35 +7073,60 @@ 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(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: kwargs["type"] = GuardrailChecksSensitiveInformationEntityType( - de.read_string(members[0]) + de.read_string( + _SCHEMA_GUARDRAIL_CHECKS_SENSITIVE_INFORMATION_RESULT_ENTRY.members[ + "type" + ] + ) ) case 1: - kwargs["confidence_score"] = de.read_double(members[1]) + kwargs["confidence_score"] = de.read_double( + _SCHEMA_GUARDRAIL_CHECKS_SENSITIVE_INFORMATION_RESULT_ENTRY.members[ + "confidenceScore" + ] + ) case 2: - kwargs["begin_offset"] = de.read_integer(members[2]) + kwargs["begin_offset"] = de.read_integer( + _SCHEMA_GUARDRAIL_CHECKS_SENSITIVE_INFORMATION_RESULT_ENTRY.members[ + "beginOffset" + ] + ) case 3: - kwargs["end_offset"] = de.read_integer(members[3]) + kwargs["end_offset"] = de.read_integer( + _SCHEMA_GUARDRAIL_CHECKS_SENSITIVE_INFORMATION_RESULT_ENTRY.members[ + "endOffset" + ] + ) case 4: - kwargs["message_index"] = de.read_integer(members[4]) + kwargs["message_index"] = de.read_integer( + _SCHEMA_GUARDRAIL_CHECKS_SENSITIVE_INFORMATION_RESULT_ENTRY.members[ + "messageIndex" + ] + ) case 5: - kwargs["content_index"] = de.read_integer(members[5]) + kwargs["content_index"] = de.read_integer( + _SCHEMA_GUARDRAIL_CHECKS_SENSITIVE_INFORMATION_RESULT_ENTRY.members[ + "contentIndex" + ] + ) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct( + _SCHEMA_GUARDRAIL_CHECKS_SENSITIVE_INFORMATION_RESULT_ENTRY, + consumer=_consumer, + ) if "type" not in kwargs: kwargs["type"] = GuardrailChecksSensitiveInformationEntityType._corrected( "" @@ -6435,7 +7149,7 @@ def _serialize_guardrail_checks_sensitive_information_result_list( schema: Schema, value: list[GuardrailChecksSensitiveInformationResultEntry], ) -> None: - member_schema = schema.members_by_index[0] + member_schema = schema.members["member"] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_struct(member_schema, e) @@ -6472,18 +7186,22 @@ class GuardrailChecksSensitiveInformationResult: def serialize(self, serializer: ShapeSerializer): serializer.write_struct( - hydrate(_SCHEMA_GUARDRAIL_CHECKS_SENSITIVE_INFORMATION_RESULT), self + _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, members[0], self.results + serializer, + _SCHEMA_GUARDRAIL_CHECKS_SENSITIVE_INFORMATION_RESULT.members["results"], + self.results, ) if self.truncated is not None: - serializer.write_boolean(members[1], self.truncated) + serializer.write_boolean( + _SCHEMA_GUARDRAIL_CHECKS_SENSITIVE_INFORMATION_RESULT.members[ + "truncated" + ], + self.truncated, + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -6492,25 +7210,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_CHECKS_SENSITIVE_INFORMATION_RESULT) - members = schema.members_by_index - def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: kwargs["results"] = ( _deserialize_guardrail_checks_sensitive_information_result_list( - de, members[0] + de, + _SCHEMA_GUARDRAIL_CHECKS_SENSITIVE_INFORMATION_RESULT.members[ + "results" + ], ) ) case 1: - kwargs["truncated"] = de.read_boolean(members[1]) + kwargs["truncated"] = de.read_boolean( + _SCHEMA_GUARDRAIL_CHECKS_SENSITIVE_INFORMATION_RESULT.members[ + "truncated" + ] + ) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct( + _SCHEMA_GUARDRAIL_CHECKS_SENSITIVE_INFORMATION_RESULT, consumer=_consumer + ) if "results" not in kwargs: kwargs["results"] = [] return kwargs @@ -6533,18 +7258,26 @@ class GuardrailChecksResults: """The sensitive information check results.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_GUARDRAIL_CHECKS_RESULTS), self) + serializer.write_struct(_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(members[0], self.content_filter) + serializer.write_struct( + _SCHEMA_GUARDRAIL_CHECKS_RESULTS.members["contentFilter"], + self.content_filter, + ) if self.prompt_attack is not None: - serializer.write_struct(members[1], self.prompt_attack) + serializer.write_struct( + _SCHEMA_GUARDRAIL_CHECKS_RESULTS.members["promptAttack"], + self.prompt_attack, + ) if self.sensitive_information is not None: - serializer.write_struct(members[2], self.sensitive_information) + serializer.write_struct( + _SCHEMA_GUARDRAIL_CHECKS_RESULTS.members["sensitiveInformation"], + self.sensitive_information, + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -6553,11 +7286,9 @@ 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(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: kwargs["content_filter"] = ( GuardrailChecksContentFilterResult.deserialize(de) @@ -6574,9 +7305,9 @@ def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: ) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct(_SCHEMA_GUARDRAIL_CHECKS_RESULTS, consumer=_consumer) return kwargs @classmethod @@ -6592,15 +7323,13 @@ class GuardrailChecksContentFilterUsage: """The number of text units consumed by the content filter check.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct( - hydrate(_SCHEMA_GUARDRAIL_CHECKS_CONTENT_FILTER_USAGE), self - ) + serializer.write_struct(_SCHEMA_GUARDRAIL_CHECKS_CONTENT_FILTER_USAGE, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate( - _SCHEMA_GUARDRAIL_CHECKS_CONTENT_FILTER_USAGE - ).members_by_index - serializer.write_integer(members[0], self.text_units) + serializer.write_integer( + _SCHEMA_GUARDRAIL_CHECKS_CONTENT_FILTER_USAGE.members["textUnits"], + self.text_units, + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -6609,18 +7338,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_USAGE) - members = schema.members_by_index - def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: - kwargs["text_units"] = de.read_integer(members[0]) + kwargs["text_units"] = de.read_integer( + _SCHEMA_GUARDRAIL_CHECKS_CONTENT_FILTER_USAGE.members[ + "textUnits" + ] + ) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct( + _SCHEMA_GUARDRAIL_CHECKS_CONTENT_FILTER_USAGE, consumer=_consumer + ) if "text_units" not in kwargs: kwargs["text_units"] = 0 return kwargs @@ -6634,13 +7367,13 @@ class GuardrailChecksPromptAttackUsage: """The number of text units consumed by the prompt attack check.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct( - hydrate(_SCHEMA_GUARDRAIL_CHECKS_PROMPT_ATTACK_USAGE), self - ) + serializer.write_struct(_SCHEMA_GUARDRAIL_CHECKS_PROMPT_ATTACK_USAGE, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_GUARDRAIL_CHECKS_PROMPT_ATTACK_USAGE).members_by_index - serializer.write_integer(members[0], self.text_units) + serializer.write_integer( + _SCHEMA_GUARDRAIL_CHECKS_PROMPT_ATTACK_USAGE.members["textUnits"], + self.text_units, + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -6649,18 +7382,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_USAGE) - members = schema.members_by_index - def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: - kwargs["text_units"] = de.read_integer(members[0]) + kwargs["text_units"] = de.read_integer( + _SCHEMA_GUARDRAIL_CHECKS_PROMPT_ATTACK_USAGE.members[ + "textUnits" + ] + ) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct( + _SCHEMA_GUARDRAIL_CHECKS_PROMPT_ATTACK_USAGE, consumer=_consumer + ) if "text_units" not in kwargs: kwargs["text_units"] = 0 return kwargs @@ -6675,14 +7412,14 @@ class GuardrailChecksSensitiveInformationUsage: def serialize(self, serializer: ShapeSerializer): serializer.write_struct( - hydrate(_SCHEMA_GUARDRAIL_CHECKS_SENSITIVE_INFORMATION_USAGE), self + _SCHEMA_GUARDRAIL_CHECKS_SENSITIVE_INFORMATION_USAGE, self ) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate( - _SCHEMA_GUARDRAIL_CHECKS_SENSITIVE_INFORMATION_USAGE - ).members_by_index - serializer.write_integer(members[0], self.text_units) + serializer.write_integer( + _SCHEMA_GUARDRAIL_CHECKS_SENSITIVE_INFORMATION_USAGE.members["textUnits"], + self.text_units, + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -6691,18 +7428,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_USAGE) - members = schema.members_by_index - def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: - kwargs["text_units"] = de.read_integer(members[0]) + kwargs["text_units"] = de.read_integer( + _SCHEMA_GUARDRAIL_CHECKS_SENSITIVE_INFORMATION_USAGE.members[ + "textUnits" + ] + ) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct( + _SCHEMA_GUARDRAIL_CHECKS_SENSITIVE_INFORMATION_USAGE, consumer=_consumer + ) if "text_units" not in kwargs: kwargs["text_units"] = 0 return kwargs @@ -6725,18 +7466,26 @@ class GuardrailChecksUsageResults: """The text unit usage for the sensitive information check.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_GUARDRAIL_CHECKS_USAGE_RESULTS), self) + serializer.write_struct(_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(members[0], self.content_filter) + serializer.write_struct( + _SCHEMA_GUARDRAIL_CHECKS_USAGE_RESULTS.members["contentFilter"], + self.content_filter, + ) if self.prompt_attack is not None: - serializer.write_struct(members[1], self.prompt_attack) + serializer.write_struct( + _SCHEMA_GUARDRAIL_CHECKS_USAGE_RESULTS.members["promptAttack"], + self.prompt_attack, + ) if self.sensitive_information is not None: - serializer.write_struct(members[2], self.sensitive_information) + serializer.write_struct( + _SCHEMA_GUARDRAIL_CHECKS_USAGE_RESULTS.members["sensitiveInformation"], + self.sensitive_information, + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -6745,11 +7494,9 @@ 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(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: kwargs["content_filter"] = ( GuardrailChecksContentFilterUsage.deserialize(de) @@ -6766,9 +7513,11 @@ def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: ) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct( + _SCHEMA_GUARDRAIL_CHECKS_USAGE_RESULTS, consumer=_consumer + ) return kwargs @classmethod @@ -6797,12 +7546,15 @@ class InvokeGuardrailChecksOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_INVOKE_GUARDRAIL_CHECKS_OUTPUT), self) + serializer.write_struct(_SCHEMA_INVOKE_GUARDRAIL_CHECKS_OUTPUT, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_INVOKE_GUARDRAIL_CHECKS_OUTPUT).members_by_index - serializer.write_struct(members[0], self.results) - serializer.write_struct(members[1], self.usage) + serializer.write_struct( + _SCHEMA_INVOKE_GUARDRAIL_CHECKS_OUTPUT.members["results"], self.results + ) + serializer.write_struct( + _SCHEMA_INVOKE_GUARDRAIL_CHECKS_OUTPUT.members["usage"], self.usage + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -6811,11 +7563,9 @@ 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(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: kwargs["results"] = GuardrailChecksResults.deserialize(de) @@ -6823,9 +7573,11 @@ def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: kwargs["usage"] = GuardrailChecksUsageResults.deserialize(de) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct( + _SCHEMA_INVOKE_GUARDRAIL_CHECKS_OUTPUT, consumer=_consumer + ) if "results" not in kwargs: kwargs["results"] = GuardrailChecksResults._smithy_default() if "usage" not in kwargs: @@ -6836,7 +7588,9 @@ def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: INVOKE_GUARDRAIL_CHECKS = APIOperation( input=InvokeGuardrailChecksInput, output=InvokeGuardrailChecksOutput, - static_schema=_SCHEMA_INVOKE_GUARDRAIL_CHECKS, + schema=_SCHEMA_INVOKE_GUARDRAIL_CHECKS, + input_schema=_SCHEMA_INVOKE_GUARDRAIL_CHECKS_INPUT, + output_schema=_SCHEMA_INVOKE_GUARDRAIL_CHECKS_OUTPUT, error_registry=TypeRegistry( { ShapeID( @@ -6860,6 +7614,13 @@ def _consumer(member_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, + ], ) @@ -6887,13 +7648,20 @@ class GuardrailConfiguration: """The trace behavior for the guardrail.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_GUARDRAIL_CONFIGURATION), self) + serializer.write_struct(_SCHEMA_GUARDRAIL_CONFIGURATION, self) def serialize_members(self, serializer: ShapeSerializer): - 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) + 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 + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -6902,31 +7670,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_CONFIGURATION) - members = schema.members_by_index - def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: - kwargs["guardrail_identifier"] = de.read_string(members[0]) + kwargs["guardrail_identifier"] = de.read_string( + _SCHEMA_GUARDRAIL_CONFIGURATION.members["guardrailIdentifier"] + ) case 1: - kwargs["guardrail_version"] = de.read_string(members[1]) + kwargs["guardrail_version"] = de.read_string( + _SCHEMA_GUARDRAIL_CONFIGURATION.members["guardrailVersion"] + ) case 2: - kwargs["trace"] = GuardrailTrace(de.read_string(members[2])) + kwargs["trace"] = GuardrailTrace( + de.read_string(_SCHEMA_GUARDRAIL_CONFIGURATION.members["trace"]) + ) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct(_SCHEMA_GUARDRAIL_CONFIGURATION, consumer=_consumer) return kwargs def _serialize_non_empty_string_list( serializer: ShapeSerializer, schema: Schema, value: list[str] ) -> None: - member_schema = schema.members_by_index[0] + member_schema = schema.members["member"] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_string(member_schema, e) @@ -6936,7 +7708,7 @@ def _deserialize_non_empty_string_list( deserializer: ShapeDeserializer, schema: Schema ) -> list[str]: result: list[str] = [] - member_schema = schema.members_by_index[0] + member_schema = schema.members["member"] def _read_value(d: ShapeDeserializer): if d.is_null(): @@ -7004,22 +7776,29 @@ class InferenceConfiguration: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_INFERENCE_CONFIGURATION), self) + serializer.write_struct(_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(members[0], self.max_tokens) + serializer.write_integer( + _SCHEMA_INFERENCE_CONFIGURATION.members["maxTokens"], self.max_tokens + ) if self.temperature is not None: - serializer.write_float(members[1], self.temperature) + serializer.write_float( + _SCHEMA_INFERENCE_CONFIGURATION.members["temperature"], self.temperature + ) if self.top_p is not None: - serializer.write_float(members[2], self.top_p) + serializer.write_float( + _SCHEMA_INFERENCE_CONFIGURATION.members["topP"], self.top_p + ) if self.stop_sequences is not None: _serialize_non_empty_string_list( - serializer, members[3], self.stop_sequences + serializer, + _SCHEMA_INFERENCE_CONFIGURATION.members["stopSequences"], + self.stop_sequences, ) @classmethod @@ -7029,29 +7808,33 @@ 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(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: - kwargs["max_tokens"] = de.read_integer(members[0]) + kwargs["max_tokens"] = de.read_integer( + _SCHEMA_INFERENCE_CONFIGURATION.members["maxTokens"] + ) case 1: - kwargs["temperature"] = de.read_float(members[1]) + kwargs["temperature"] = de.read_float( + _SCHEMA_INFERENCE_CONFIGURATION.members["temperature"] + ) case 2: - kwargs["top_p"] = de.read_float(members[2]) + kwargs["top_p"] = de.read_float( + _SCHEMA_INFERENCE_CONFIGURATION.members["topP"] + ) case 3: kwargs["stop_sequences"] = _deserialize_non_empty_string_list( - de, members[3] + de, _SCHEMA_INFERENCE_CONFIGURATION.members["stopSequences"] ) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct(_SCHEMA_INFERENCE_CONFIGURATION, consumer=_consumer) return kwargs @@ -7066,12 +7849,13 @@ class ErrorBlock: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_ERROR_BLOCK), self) + serializer.write_struct(_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(members[0], self.message) + serializer.write_string( + _SCHEMA_ERROR_BLOCK.members["message"], self.message + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -7080,18 +7864,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(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: - kwargs["message"] = de.read_string(members[0]) + kwargs["message"] = de.read_string( + _SCHEMA_ERROR_BLOCK.members["message"] + ) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct(_SCHEMA_ERROR_BLOCK, consumer=_consumer) return kwargs @@ -7127,13 +7911,14 @@ class S3Location: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_S3_LOCATION), self) + serializer.write_struct(_SCHEMA_S3_LOCATION, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_S3_LOCATION).members_by_index - serializer.write_string(members[0], self.uri) + serializer.write_string(_SCHEMA_S3_LOCATION.members["uri"], self.uri) if self.bucket_owner is not None: - serializer.write_string(members[1], self.bucket_owner) + serializer.write_string( + _SCHEMA_S3_LOCATION.members["bucketOwner"], self.bucket_owner + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -7142,21 +7927,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(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: - kwargs["uri"] = de.read_string(members[0]) + kwargs["uri"] = de.read_string(_SCHEMA_S3_LOCATION.members["uri"]) case 1: - kwargs["bucket_owner"] = de.read_string(members[1]) + kwargs["bucket_owner"] = de.read_string( + _SCHEMA_S3_LOCATION.members["bucketOwner"] + ) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct(_SCHEMA_S3_LOCATION, consumer=_consumer) if "uri" not in kwargs: kwargs["uri"] = "" return kwargs @@ -7169,16 +7954,14 @@ class AudioSourceBytes: value: bytes def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_AUDIO_SOURCE), self) + serializer.write_struct(_SCHEMA_AUDIO_SOURCE, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_AUDIO_SOURCE).members_by_index - serializer.write_blob(members[0], self.value) + serializer.write_blob(_SCHEMA_AUDIO_SOURCE.members["bytes"], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: - members = hydrate(_SCHEMA_AUDIO_SOURCE).members_by_index - return cls(value=deserializer.read_blob(members[0])) + return cls(value=deserializer.read_blob(_SCHEMA_AUDIO_SOURCE.members["bytes"])) @dataclass @@ -7192,11 +7975,10 @@ class AudioSourceS3Location: value: S3Location def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_AUDIO_SOURCE), self) + serializer.write_struct(_SCHEMA_AUDIO_SOURCE, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_AUDIO_SOURCE).members_by_index - serializer.write_struct(members[1], self.value) + serializer.write_struct(_SCHEMA_AUDIO_SOURCE.members["s3Location"], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -7239,7 +8021,7 @@ class _AudioSourceDeserializer: def deserialize(self, deserializer: ShapeDeserializer) -> AudioSource: self._result = None - deserializer.read_struct(hydrate(_SCHEMA_AUDIO_SOURCE), self._consumer) + deserializer.read_struct(_SCHEMA_AUDIO_SOURCE, self._consumer) if self._result is None: raise SerializationError( @@ -7293,14 +8075,13 @@ class AudioBlock: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_AUDIO_BLOCK), self) + serializer.write_struct(_SCHEMA_AUDIO_BLOCK, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_AUDIO_BLOCK).members_by_index - serializer.write_string(members[0], self.format) - serializer.write_struct(members[1], self.source) + serializer.write_string(_SCHEMA_AUDIO_BLOCK.members["format"], self.format) + serializer.write_struct(_SCHEMA_AUDIO_BLOCK.members["source"], self.source) if self.error is not None: - serializer.write_struct(members[2], self.error) + serializer.write_struct(_SCHEMA_AUDIO_BLOCK.members["error"], self.error) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -7309,13 +8090,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(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: - kwargs["format"] = AudioFormat(de.read_string(members[0])) + kwargs["format"] = AudioFormat( + de.read_string(_SCHEMA_AUDIO_BLOCK.members["format"]) + ) case 1: kwargs["source"] = _AudioSourceDeserializer().deserialize(de) @@ -7324,9 +8105,9 @@ def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: kwargs["error"] = ErrorBlock.deserialize(de) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct(_SCHEMA_AUDIO_BLOCK, consumer=_consumer) if "format" not in kwargs: kwargs["format"] = AudioFormat._corrected("") if "source" not in kwargs: @@ -7363,13 +8144,12 @@ class CachePointBlock: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_CACHE_POINT_BLOCK), self) + serializer.write_struct(_SCHEMA_CACHE_POINT_BLOCK, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_CACHE_POINT_BLOCK).members_by_index - serializer.write_string(members[0], self.type) + serializer.write_string(_SCHEMA_CACHE_POINT_BLOCK.members["type"], self.type) if self.ttl is not None: - serializer.write_string(members[1], self.ttl) + serializer.write_string(_SCHEMA_CACHE_POINT_BLOCK.members["ttl"], self.ttl) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -7378,21 +8158,23 @@ 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(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: - kwargs["type"] = CachePointType(de.read_string(members[0])) + kwargs["type"] = CachePointType( + de.read_string(_SCHEMA_CACHE_POINT_BLOCK.members["type"]) + ) case 1: - kwargs["ttl"] = CacheTTL(de.read_string(members[1])) + kwargs["ttl"] = CacheTTL( + de.read_string(_SCHEMA_CACHE_POINT_BLOCK.members["ttl"]) + ) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct(_SCHEMA_CACHE_POINT_BLOCK, consumer=_consumer) if "type" not in kwargs: kwargs["type"] = CachePointType._corrected("") return kwargs @@ -7422,18 +8204,24 @@ class DocumentCharLocation: """The ending character position of the cited content within the document.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_DOCUMENT_CHAR_LOCATION), self) + serializer.write_struct(_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(members[0], self.document_index) + serializer.write_integer( + _SCHEMA_DOCUMENT_CHAR_LOCATION.members["documentIndex"], + self.document_index, + ) if self.start is not None: - serializer.write_integer(members[1], self.start) + serializer.write_integer( + _SCHEMA_DOCUMENT_CHAR_LOCATION.members["start"], self.start + ) if self.end is not None: - serializer.write_integer(members[2], self.end) + serializer.write_integer( + _SCHEMA_DOCUMENT_CHAR_LOCATION.members["end"], self.end + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -7442,24 +8230,28 @@ 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(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: - kwargs["document_index"] = de.read_integer(members[0]) + kwargs["document_index"] = de.read_integer( + _SCHEMA_DOCUMENT_CHAR_LOCATION.members["documentIndex"] + ) case 1: - kwargs["start"] = de.read_integer(members[1]) + kwargs["start"] = de.read_integer( + _SCHEMA_DOCUMENT_CHAR_LOCATION.members["start"] + ) case 2: - kwargs["end"] = de.read_integer(members[2]) + kwargs["end"] = de.read_integer( + _SCHEMA_DOCUMENT_CHAR_LOCATION.members["end"] + ) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct(_SCHEMA_DOCUMENT_CHAR_LOCATION, consumer=_consumer) return kwargs @@ -7490,18 +8282,24 @@ class DocumentChunkLocation: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_DOCUMENT_CHUNK_LOCATION), self) + serializer.write_struct(_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(members[0], self.document_index) + serializer.write_integer( + _SCHEMA_DOCUMENT_CHUNK_LOCATION.members["documentIndex"], + self.document_index, + ) if self.start is not None: - serializer.write_integer(members[1], self.start) + serializer.write_integer( + _SCHEMA_DOCUMENT_CHUNK_LOCATION.members["start"], self.start + ) if self.end is not None: - serializer.write_integer(members[2], self.end) + serializer.write_integer( + _SCHEMA_DOCUMENT_CHUNK_LOCATION.members["end"], self.end + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -7510,24 +8308,28 @@ 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(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: - kwargs["document_index"] = de.read_integer(members[0]) + kwargs["document_index"] = de.read_integer( + _SCHEMA_DOCUMENT_CHUNK_LOCATION.members["documentIndex"] + ) case 1: - kwargs["start"] = de.read_integer(members[1]) + kwargs["start"] = de.read_integer( + _SCHEMA_DOCUMENT_CHUNK_LOCATION.members["start"] + ) case 2: - kwargs["end"] = de.read_integer(members[2]) + kwargs["end"] = de.read_integer( + _SCHEMA_DOCUMENT_CHUNK_LOCATION.members["end"] + ) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct(_SCHEMA_DOCUMENT_CHUNK_LOCATION, consumer=_consumer) return kwargs @@ -7551,18 +8353,24 @@ class DocumentPageLocation: """The ending page number of the cited content within the document.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_DOCUMENT_PAGE_LOCATION), self) + serializer.write_struct(_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(members[0], self.document_index) + serializer.write_integer( + _SCHEMA_DOCUMENT_PAGE_LOCATION.members["documentIndex"], + self.document_index, + ) if self.start is not None: - serializer.write_integer(members[1], self.start) + serializer.write_integer( + _SCHEMA_DOCUMENT_PAGE_LOCATION.members["start"], self.start + ) if self.end is not None: - serializer.write_integer(members[2], self.end) + serializer.write_integer( + _SCHEMA_DOCUMENT_PAGE_LOCATION.members["end"], self.end + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -7571,24 +8379,28 @@ 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(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: - kwargs["document_index"] = de.read_integer(members[0]) + kwargs["document_index"] = de.read_integer( + _SCHEMA_DOCUMENT_PAGE_LOCATION.members["documentIndex"] + ) case 1: - kwargs["start"] = de.read_integer(members[1]) + kwargs["start"] = de.read_integer( + _SCHEMA_DOCUMENT_PAGE_LOCATION.members["start"] + ) case 2: - kwargs["end"] = de.read_integer(members[2]) + kwargs["end"] = de.read_integer( + _SCHEMA_DOCUMENT_PAGE_LOCATION.members["end"] + ) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct(_SCHEMA_DOCUMENT_PAGE_LOCATION, consumer=_consumer) return kwargs @@ -7616,18 +8428,24 @@ class SearchResultLocation: """The ending position in the content array where the cited content ends.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_SEARCH_RESULT_LOCATION), self) + serializer.write_struct(_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(members[0], self.search_result_index) + serializer.write_integer( + _SCHEMA_SEARCH_RESULT_LOCATION.members["searchResultIndex"], + self.search_result_index, + ) if self.start is not None: - serializer.write_integer(members[1], self.start) + serializer.write_integer( + _SCHEMA_SEARCH_RESULT_LOCATION.members["start"], self.start + ) if self.end is not None: - serializer.write_integer(members[2], self.end) + serializer.write_integer( + _SCHEMA_SEARCH_RESULT_LOCATION.members["end"], self.end + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -7636,24 +8454,28 @@ 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(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: - kwargs["search_result_index"] = de.read_integer(members[0]) + kwargs["search_result_index"] = de.read_integer( + _SCHEMA_SEARCH_RESULT_LOCATION.members["searchResultIndex"] + ) case 1: - kwargs["start"] = de.read_integer(members[1]) + kwargs["start"] = de.read_integer( + _SCHEMA_SEARCH_RESULT_LOCATION.members["start"] + ) case 2: - kwargs["end"] = de.read_integer(members[2]) + kwargs["end"] = de.read_integer( + _SCHEMA_SEARCH_RESULT_LOCATION.members["end"] + ) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct(_SCHEMA_SEARCH_RESULT_LOCATION, consumer=_consumer) return kwargs @@ -7671,15 +8493,14 @@ class WebLocation: """The domain that was cited when performing a web search.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_WEB_LOCATION), self) + serializer.write_struct(_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(members[0], self.url) + serializer.write_string(_SCHEMA_WEB_LOCATION.members["url"], self.url) if self.domain is not None: - serializer.write_string(members[1], self.domain) + serializer.write_string(_SCHEMA_WEB_LOCATION.members["domain"], self.domain) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -7688,21 +8509,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(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: - kwargs["url"] = de.read_string(members[0]) + kwargs["url"] = de.read_string(_SCHEMA_WEB_LOCATION.members["url"]) case 1: - kwargs["domain"] = de.read_string(members[1]) + kwargs["domain"] = de.read_string( + _SCHEMA_WEB_LOCATION.members["domain"] + ) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct(_SCHEMA_WEB_LOCATION, consumer=_consumer) return kwargs @@ -7713,11 +8534,10 @@ class CitationLocationWeb: value: WebLocation def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_CITATION_LOCATION), self) + serializer.write_struct(_SCHEMA_CITATION_LOCATION, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_CITATION_LOCATION).members_by_index - serializer.write_struct(members[0], self.value) + serializer.write_struct(_SCHEMA_CITATION_LOCATION.members["web"], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -7734,11 +8554,12 @@ class CitationLocationDocumentChar: value: DocumentCharLocation def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_CITATION_LOCATION), self) + serializer.write_struct(_SCHEMA_CITATION_LOCATION, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_CITATION_LOCATION).members_by_index - serializer.write_struct(members[1], self.value) + serializer.write_struct( + _SCHEMA_CITATION_LOCATION.members["documentChar"], self.value + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -7755,11 +8576,12 @@ class CitationLocationDocumentPage: value: DocumentPageLocation def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_CITATION_LOCATION), self) + serializer.write_struct(_SCHEMA_CITATION_LOCATION, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_CITATION_LOCATION).members_by_index - serializer.write_struct(members[2], self.value) + serializer.write_struct( + _SCHEMA_CITATION_LOCATION.members["documentPage"], self.value + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -7777,11 +8599,12 @@ class CitationLocationDocumentChunk: value: DocumentChunkLocation def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_CITATION_LOCATION), self) + serializer.write_struct(_SCHEMA_CITATION_LOCATION, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_CITATION_LOCATION).members_by_index - serializer.write_struct(members[3], self.value) + serializer.write_struct( + _SCHEMA_CITATION_LOCATION.members["documentChunk"], self.value + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -7798,11 +8621,12 @@ class CitationLocationSearchResultLocation: value: SearchResultLocation def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_CITATION_LOCATION), self) + serializer.write_struct(_SCHEMA_CITATION_LOCATION, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_CITATION_LOCATION).members_by_index - serializer.write_struct(members[4], self.value) + serializer.write_struct( + _SCHEMA_CITATION_LOCATION.members["searchResultLocation"], self.value + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -7854,7 +8678,7 @@ class _CitationLocationDeserializer: def deserialize(self, deserializer: ShapeDeserializer) -> CitationLocation: self._result = None - deserializer.read_struct(hydrate(_SCHEMA_CITATION_LOCATION), self._consumer) + deserializer.read_struct(_SCHEMA_CITATION_LOCATION, self._consumer) if self._result is None: raise SerializationError( @@ -7900,16 +8724,20 @@ class CitationSourceContentText: value: str def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_CITATION_SOURCE_CONTENT), self) + serializer.write_struct(_SCHEMA_CITATION_SOURCE_CONTENT, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_CITATION_SOURCE_CONTENT).members_by_index - serializer.write_string(members[0], self.value) + serializer.write_string( + _SCHEMA_CITATION_SOURCE_CONTENT.members["text"], self.value + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: - members = hydrate(_SCHEMA_CITATION_SOURCE_CONTENT).members_by_index - return cls(value=deserializer.read_string(members[0])) + return cls( + value=deserializer.read_string( + _SCHEMA_CITATION_SOURCE_CONTENT.members["text"] + ) + ) @dataclass @@ -7948,9 +8776,7 @@ class _CitationSourceContentDeserializer: def deserialize(self, deserializer: ShapeDeserializer) -> CitationSourceContent: self._result = None - deserializer.read_struct( - hydrate(_SCHEMA_CITATION_SOURCE_CONTENT), self._consumer - ) + deserializer.read_struct(_SCHEMA_CITATION_SOURCE_CONTENT, self._consumer) if self._result is None: raise SerializationError( @@ -7980,7 +8806,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_by_index[0] + member_schema = schema.members["member"] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_struct(member_schema, e) @@ -8033,23 +8859,24 @@ class Citation: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_CITATION), self) + serializer.write_struct(_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(members[0], self.title) + serializer.write_string(_SCHEMA_CITATION.members["title"], self.title) if self.source is not None: - serializer.write_string(members[1], self.source) + serializer.write_string(_SCHEMA_CITATION.members["source"], self.source) if self.source_content is not None: _serialize_citation_source_content_list( - serializer, members[2], self.source_content + serializer, + _SCHEMA_CITATION.members["sourceContent"], + self.source_content, ) if self.location is not None: - serializer.write_struct(members[3], self.location) + serializer.write_struct(_SCHEMA_CITATION.members["location"], self.location) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -8058,36 +8885,38 @@ 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(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: - kwargs["title"] = de.read_string(members[0]) + kwargs["title"] = de.read_string(_SCHEMA_CITATION.members["title"]) case 1: - kwargs["source"] = de.read_string(members[1]) + kwargs["source"] = de.read_string( + _SCHEMA_CITATION.members["source"] + ) case 2: kwargs["source_content"] = ( - _deserialize_citation_source_content_list(de, members[2]) + _deserialize_citation_source_content_list( + de, _SCHEMA_CITATION.members["sourceContent"] + ) ) case 3: kwargs["location"] = _CitationLocationDeserializer().deserialize(de) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct(_SCHEMA_CITATION, consumer=_consumer) return kwargs def _serialize_citations( serializer: ShapeSerializer, schema: Schema, value: list[Citation] ) -> None: - member_schema = schema.members_by_index[0] + member_schema = schema.members["member"] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_struct(member_schema, e) @@ -8119,16 +8948,20 @@ class CitationGeneratedContentText: value: str def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_CITATION_GENERATED_CONTENT), self) + serializer.write_struct(_SCHEMA_CITATION_GENERATED_CONTENT, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_CITATION_GENERATED_CONTENT).members_by_index - serializer.write_string(members[0], self.value) + serializer.write_string( + _SCHEMA_CITATION_GENERATED_CONTENT.members["text"], self.value + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: - members = hydrate(_SCHEMA_CITATION_GENERATED_CONTENT).members_by_index - return cls(value=deserializer.read_string(members[0])) + return cls( + value=deserializer.read_string( + _SCHEMA_CITATION_GENERATED_CONTENT.members["text"] + ) + ) @dataclass @@ -8169,9 +9002,7 @@ class _CitationGeneratedContentDeserializer: def deserialize(self, deserializer: ShapeDeserializer) -> CitationGeneratedContent: self._result = None - deserializer.read_struct( - hydrate(_SCHEMA_CITATION_GENERATED_CONTENT), self._consumer - ) + deserializer.read_struct(_SCHEMA_CITATION_GENERATED_CONTENT, self._consumer) if self._result is None: raise SerializationError( @@ -8201,7 +9032,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_by_index[0] + member_schema = schema.members["member"] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_struct(member_schema, e) @@ -8242,17 +9073,22 @@ class CitationsContentBlock: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_CITATIONS_CONTENT_BLOCK), self) + serializer.write_struct(_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, members[0], self.content + serializer, + _SCHEMA_CITATIONS_CONTENT_BLOCK.members["content"], + self.content, ) if self.citations is not None: - _serialize_citations(serializer, members[1], self.citations) + _serialize_citations( + serializer, + _SCHEMA_CITATIONS_CONTENT_BLOCK.members["citations"], + self.citations, + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -8261,23 +9097,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(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: kwargs["content"] = _deserialize_citation_generated_content_list( - de, members[0] + de, _SCHEMA_CITATIONS_CONTENT_BLOCK.members["content"] ) case 1: - kwargs["citations"] = _deserialize_citations(de, members[1]) + kwargs["citations"] = _deserialize_citations( + de, _SCHEMA_CITATIONS_CONTENT_BLOCK.members["citations"] + ) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct(_SCHEMA_CITATIONS_CONTENT_BLOCK, consumer=_consumer) return kwargs @@ -8299,11 +9135,12 @@ class CitationsConfig: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_CITATIONS_CONFIG), self) + serializer.write_struct(_SCHEMA_CITATIONS_CONFIG, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_CITATIONS_CONFIG).members_by_index - serializer.write_boolean(members[0], self.enabled) + serializer.write_boolean( + _SCHEMA_CITATIONS_CONFIG.members["enabled"], self.enabled + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -8312,18 +9149,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(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: - kwargs["enabled"] = de.read_boolean(members[0]) + kwargs["enabled"] = de.read_boolean( + _SCHEMA_CITATIONS_CONFIG.members["enabled"] + ) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct(_SCHEMA_CITATIONS_CONFIG, consumer=_consumer) if "enabled" not in kwargs: kwargs["enabled"] = False return kwargs @@ -8348,16 +9185,20 @@ class DocumentContentBlockText: value: str def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_DOCUMENT_CONTENT_BLOCK), self) + serializer.write_struct(_SCHEMA_DOCUMENT_CONTENT_BLOCK, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_DOCUMENT_CONTENT_BLOCK).members_by_index - serializer.write_string(members[0], self.value) + serializer.write_string( + _SCHEMA_DOCUMENT_CONTENT_BLOCK.members["text"], self.value + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: - members = hydrate(_SCHEMA_DOCUMENT_CONTENT_BLOCK).members_by_index - return cls(value=deserializer.read_string(members[0])) + return cls( + value=deserializer.read_string( + _SCHEMA_DOCUMENT_CONTENT_BLOCK.members["text"] + ) + ) @dataclass @@ -8396,9 +9237,7 @@ class _DocumentContentBlockDeserializer: def deserialize(self, deserializer: ShapeDeserializer) -> DocumentContentBlock: self._result = None - deserializer.read_struct( - hydrate(_SCHEMA_DOCUMENT_CONTENT_BLOCK), self._consumer - ) + deserializer.read_struct(_SCHEMA_DOCUMENT_CONTENT_BLOCK, self._consumer) if self._result is None: raise SerializationError( @@ -8428,7 +9267,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_by_index[0] + member_schema = schema.members["member"] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_struct(member_schema, e) @@ -8460,16 +9299,16 @@ class DocumentSourceBytes: value: bytes def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_DOCUMENT_SOURCE), self) + serializer.write_struct(_SCHEMA_DOCUMENT_SOURCE, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_DOCUMENT_SOURCE).members_by_index - serializer.write_blob(members[0], self.value) + serializer.write_blob(_SCHEMA_DOCUMENT_SOURCE.members["bytes"], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: - members = hydrate(_SCHEMA_DOCUMENT_SOURCE).members_by_index - return cls(value=deserializer.read_blob(members[0])) + return cls( + value=deserializer.read_blob(_SCHEMA_DOCUMENT_SOURCE.members["bytes"]) + ) @dataclass @@ -8483,11 +9322,12 @@ class DocumentSourceS3Location: value: S3Location def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_DOCUMENT_SOURCE), self) + serializer.write_struct(_SCHEMA_DOCUMENT_SOURCE, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_DOCUMENT_SOURCE).members_by_index - serializer.write_struct(members[1], self.value) + serializer.write_struct( + _SCHEMA_DOCUMENT_SOURCE.members["s3Location"], self.value + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -8501,16 +9341,16 @@ class DocumentSourceText: value: str def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_DOCUMENT_SOURCE), self) + serializer.write_struct(_SCHEMA_DOCUMENT_SOURCE, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_DOCUMENT_SOURCE).members_by_index - serializer.write_string(members[2], self.value) + serializer.write_string(_SCHEMA_DOCUMENT_SOURCE.members["text"], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: - members = hydrate(_SCHEMA_DOCUMENT_SOURCE).members_by_index - return cls(value=deserializer.read_string(members[2])) + return cls( + value=deserializer.read_string(_SCHEMA_DOCUMENT_SOURCE.members["text"]) + ) @dataclass @@ -8523,16 +9363,20 @@ class DocumentSourceContent: value: list[DocumentContentBlock] def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_DOCUMENT_SOURCE), self) + serializer.write_struct(_SCHEMA_DOCUMENT_SOURCE, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_DOCUMENT_SOURCE).members_by_index - _serialize_document_content_blocks(serializer, members[3], self.value) + _serialize_document_content_blocks( + serializer, _SCHEMA_DOCUMENT_SOURCE.members["content"], self.value + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: - members = hydrate(_SCHEMA_DOCUMENT_SOURCE).members_by_index - return cls(value=_deserialize_document_content_blocks(deserializer, members[3])) + return cls( + value=_deserialize_document_content_blocks( + deserializer, _SCHEMA_DOCUMENT_SOURCE.members["content"] + ) + ) @dataclass @@ -8574,7 +9418,7 @@ class _DocumentSourceDeserializer: def deserialize(self, deserializer: ShapeDeserializer) -> DocumentSource: self._result = None - deserializer.read_struct(hydrate(_SCHEMA_DOCUMENT_SOURCE), self._consumer) + deserializer.read_struct(_SCHEMA_DOCUMENT_SOURCE, self._consumer) if self._result is None: raise SerializationError( @@ -8652,18 +9496,21 @@ class DocumentBlock: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_DOCUMENT_BLOCK), self) + serializer.write_struct(_SCHEMA_DOCUMENT_BLOCK, self) def serialize_members(self, serializer: ShapeSerializer): - 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) + 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) if self.context is not None: - serializer.write_string(members[3], self.context) + serializer.write_string( + _SCHEMA_DOCUMENT_BLOCK.members["context"], self.context + ) if self.citations is not None: - serializer.write_struct(members[4], self.citations) + serializer.write_struct( + _SCHEMA_DOCUMENT_BLOCK.members["citations"], self.citations + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -8672,30 +9519,34 @@ 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(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: - kwargs["format"] = DocumentFormat(de.read_string(members[0])) + kwargs["format"] = DocumentFormat( + de.read_string(_SCHEMA_DOCUMENT_BLOCK.members["format"]) + ) case 1: - kwargs["name"] = de.read_string(members[1]) + kwargs["name"] = de.read_string( + _SCHEMA_DOCUMENT_BLOCK.members["name"] + ) case 2: kwargs["source"] = _DocumentSourceDeserializer().deserialize(de) case 3: - kwargs["context"] = de.read_string(members[3]) + kwargs["context"] = de.read_string( + _SCHEMA_DOCUMENT_BLOCK.members["context"] + ) case 4: kwargs["citations"] = CitationsConfig.deserialize(de) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct(_SCHEMA_DOCUMENT_BLOCK, consumer=_consumer) if "name" not in kwargs: kwargs["name"] = "" if "source" not in kwargs: @@ -8715,16 +9566,20 @@ class GuardrailConverseImageSourceBytes: value: bytes def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_GUARDRAIL_CONVERSE_IMAGE_SOURCE), self) + serializer.write_struct(_SCHEMA_GUARDRAIL_CONVERSE_IMAGE_SOURCE, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_GUARDRAIL_CONVERSE_IMAGE_SOURCE).members_by_index - serializer.write_blob(members[0], self.value) + serializer.write_blob( + _SCHEMA_GUARDRAIL_CONVERSE_IMAGE_SOURCE.members["bytes"], self.value + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: - members = hydrate(_SCHEMA_GUARDRAIL_CONVERSE_IMAGE_SOURCE).members_by_index - return cls(value=deserializer.read_blob(members[0])) + return cls( + value=deserializer.read_blob( + _SCHEMA_GUARDRAIL_CONVERSE_IMAGE_SOURCE.members["bytes"] + ) + ) @dataclass @@ -8765,7 +9620,7 @@ def deserialize( ) -> GuardrailConverseImageSource: self._result = None deserializer.read_struct( - hydrate(_SCHEMA_GUARDRAIL_CONVERSE_IMAGE_SOURCE), self._consumer + _SCHEMA_GUARDRAIL_CONVERSE_IMAGE_SOURCE, self._consumer ) if self._result is None: @@ -8810,12 +9665,15 @@ class GuardrailConverseImageBlock: """The image source (image bytes) of the guardrail converse image block.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_GUARDRAIL_CONVERSE_IMAGE_BLOCK), self) + serializer.write_struct(_SCHEMA_GUARDRAIL_CONVERSE_IMAGE_BLOCK, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_GUARDRAIL_CONVERSE_IMAGE_BLOCK).members_by_index - serializer.write_string(members[0], self.format) - serializer.write_struct(members[1], self.source) + serializer.write_string( + _SCHEMA_GUARDRAIL_CONVERSE_IMAGE_BLOCK.members["format"], self.format + ) + serializer.write_struct( + _SCHEMA_GUARDRAIL_CONVERSE_IMAGE_BLOCK.members["source"], self.source + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -8824,14 +9682,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(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: kwargs["format"] = GuardrailConverseImageFormat( - de.read_string(members[0]) + de.read_string( + _SCHEMA_GUARDRAIL_CONVERSE_IMAGE_BLOCK.members["format"] + ) ) case 1: @@ -8840,9 +9698,11 @@ def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: ) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct( + _SCHEMA_GUARDRAIL_CONVERSE_IMAGE_BLOCK, consumer=_consumer + ) if "format" not in kwargs: kwargs["format"] = GuardrailConverseImageFormat._corrected("") if "source" not in kwargs: @@ -8859,7 +9719,7 @@ class GuardrailConverseContentQualifier(UnknownEnumMixin, StrEnum): def _serialize_guardrail_converse_content_qualifier_list( serializer: ShapeSerializer, schema: Schema, value: list[str] ) -> None: - member_schema = schema.members_by_index[0] + member_schema = schema.members["member"] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_string(member_schema, e) @@ -8869,7 +9729,7 @@ def _deserialize_guardrail_converse_content_qualifier_list( deserializer: ShapeDeserializer, schema: Schema ) -> list[str]: result: list[str] = [] - member_schema = schema.members_by_index[0] + member_schema = schema.members["member"] def _read_value(d: ShapeDeserializer): if d.is_null(): @@ -8899,14 +9759,17 @@ class GuardrailConverseTextBlock: """The qualifier details for the guardrails contextual grounding filter.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_GUARDRAIL_CONVERSE_TEXT_BLOCK), self) + serializer.write_struct(_SCHEMA_GUARDRAIL_CONVERSE_TEXT_BLOCK, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_GUARDRAIL_CONVERSE_TEXT_BLOCK).members_by_index - serializer.write_string(members[0], self.text) + serializer.write_string( + _SCHEMA_GUARDRAIL_CONVERSE_TEXT_BLOCK.members["text"], self.text + ) if self.qualifiers is not None: _serialize_guardrail_converse_content_qualifier_list( - serializer, members[1], self.qualifiers + serializer, + _SCHEMA_GUARDRAIL_CONVERSE_TEXT_BLOCK.members["qualifiers"], + self.qualifiers, ) @classmethod @@ -8916,25 +9779,28 @@ 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(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: - kwargs["text"] = de.read_string(members[0]) + kwargs["text"] = de.read_string( + _SCHEMA_GUARDRAIL_CONVERSE_TEXT_BLOCK.members["text"] + ) case 1: kwargs["qualifiers"] = ( _deserialize_guardrail_converse_content_qualifier_list( - de, members[1] + de, + _SCHEMA_GUARDRAIL_CONVERSE_TEXT_BLOCK.members["qualifiers"], ) ) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct( + _SCHEMA_GUARDRAIL_CONVERSE_TEXT_BLOCK, consumer=_consumer + ) if "text" not in kwargs: kwargs["text"] = "" return kwargs @@ -8947,11 +9813,12 @@ class GuardrailConverseContentBlockText: value: GuardrailConverseTextBlock def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_GUARDRAIL_CONVERSE_CONTENT_BLOCK), self) + serializer.write_struct(_SCHEMA_GUARDRAIL_CONVERSE_CONTENT_BLOCK, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_GUARDRAIL_CONVERSE_CONTENT_BLOCK).members_by_index - serializer.write_struct(members[0], self.value) + serializer.write_struct( + _SCHEMA_GUARDRAIL_CONVERSE_CONTENT_BLOCK.members["text"], self.value + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -8965,11 +9832,12 @@ class GuardrailConverseContentBlockImage: value: GuardrailConverseImageBlock def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_GUARDRAIL_CONVERSE_CONTENT_BLOCK), self) + serializer.write_struct(_SCHEMA_GUARDRAIL_CONVERSE_CONTENT_BLOCK, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_GUARDRAIL_CONVERSE_CONTENT_BLOCK).members_by_index - serializer.write_struct(members[1], self.value) + serializer.write_struct( + _SCHEMA_GUARDRAIL_CONVERSE_CONTENT_BLOCK.members["image"], self.value + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -9022,7 +9890,7 @@ def deserialize( ) -> GuardrailConverseContentBlock: self._result = None deserializer.read_struct( - hydrate(_SCHEMA_GUARDRAIL_CONVERSE_CONTENT_BLOCK), self._consumer + _SCHEMA_GUARDRAIL_CONVERSE_CONTENT_BLOCK, self._consumer ) if self._result is None: @@ -9072,16 +9940,14 @@ class ImageSourceBytes: value: bytes def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_IMAGE_SOURCE), self) + serializer.write_struct(_SCHEMA_IMAGE_SOURCE, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_IMAGE_SOURCE).members_by_index - serializer.write_blob(members[0], self.value) + serializer.write_blob(_SCHEMA_IMAGE_SOURCE.members["bytes"], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: - members = hydrate(_SCHEMA_IMAGE_SOURCE).members_by_index - return cls(value=deserializer.read_blob(members[0])) + return cls(value=deserializer.read_blob(_SCHEMA_IMAGE_SOURCE.members["bytes"])) @dataclass @@ -9095,11 +9961,10 @@ class ImageSourceS3Location: value: S3Location def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_IMAGE_SOURCE), self) + serializer.write_struct(_SCHEMA_IMAGE_SOURCE, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_IMAGE_SOURCE).members_by_index - serializer.write_struct(members[1], self.value) + serializer.write_struct(_SCHEMA_IMAGE_SOURCE.members["s3Location"], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -9139,7 +10004,7 @@ class _ImageSourceDeserializer: def deserialize(self, deserializer: ShapeDeserializer) -> ImageSource: self._result = None - deserializer.read_struct(hydrate(_SCHEMA_IMAGE_SOURCE), self._consumer) + deserializer.read_struct(_SCHEMA_IMAGE_SOURCE, self._consumer) if self._result is None: raise SerializationError( @@ -9184,14 +10049,13 @@ class ImageBlock: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_IMAGE_BLOCK), self) + serializer.write_struct(_SCHEMA_IMAGE_BLOCK, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_IMAGE_BLOCK).members_by_index - serializer.write_string(members[0], self.format) - serializer.write_struct(members[1], self.source) + serializer.write_string(_SCHEMA_IMAGE_BLOCK.members["format"], self.format) + serializer.write_struct(_SCHEMA_IMAGE_BLOCK.members["source"], self.source) if self.error is not None: - serializer.write_struct(members[2], self.error) + serializer.write_struct(_SCHEMA_IMAGE_BLOCK.members["error"], self.error) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -9200,13 +10064,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(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: - kwargs["format"] = ImageFormat(de.read_string(members[0])) + kwargs["format"] = ImageFormat( + de.read_string(_SCHEMA_IMAGE_BLOCK.members["format"]) + ) case 1: kwargs["source"] = _ImageSourceDeserializer().deserialize(de) @@ -9215,9 +10079,9 @@ def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: kwargs["error"] = ErrorBlock.deserialize(de) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct(_SCHEMA_IMAGE_BLOCK, consumer=_consumer) if "format" not in kwargs: kwargs["format"] = ImageFormat._corrected("") if "source" not in kwargs: @@ -9240,13 +10104,14 @@ class ReasoningTextBlock: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_REASONING_TEXT_BLOCK), self) + serializer.write_struct(_SCHEMA_REASONING_TEXT_BLOCK, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_REASONING_TEXT_BLOCK).members_by_index - serializer.write_string(members[0], self.text) + serializer.write_string(_SCHEMA_REASONING_TEXT_BLOCK.members["text"], self.text) if self.signature is not None: - serializer.write_string(members[1], self.signature) + serializer.write_string( + _SCHEMA_REASONING_TEXT_BLOCK.members["signature"], self.signature + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -9255,21 +10120,23 @@ 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(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: - kwargs["text"] = de.read_string(members[0]) + kwargs["text"] = de.read_string( + _SCHEMA_REASONING_TEXT_BLOCK.members["text"] + ) case 1: - kwargs["signature"] = de.read_string(members[1]) + kwargs["signature"] = de.read_string( + _SCHEMA_REASONING_TEXT_BLOCK.members["signature"] + ) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct(_SCHEMA_REASONING_TEXT_BLOCK, consumer=_consumer) if "text" not in kwargs: kwargs["text"] = "" return kwargs @@ -9282,11 +10149,12 @@ class ReasoningContentBlockReasoningText: value: ReasoningTextBlock def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_REASONING_CONTENT_BLOCK), self) + serializer.write_struct(_SCHEMA_REASONING_CONTENT_BLOCK, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_REASONING_CONTENT_BLOCK).members_by_index - serializer.write_struct(members[0], self.value) + serializer.write_struct( + _SCHEMA_REASONING_CONTENT_BLOCK.members["reasoningText"], self.value + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -9304,16 +10172,20 @@ class ReasoningContentBlockRedactedContent: value: bytes def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_REASONING_CONTENT_BLOCK), self) + serializer.write_struct(_SCHEMA_REASONING_CONTENT_BLOCK, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_REASONING_CONTENT_BLOCK).members_by_index - serializer.write_blob(members[1], self.value) + serializer.write_blob( + _SCHEMA_REASONING_CONTENT_BLOCK.members["redactedContent"], self.value + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: - members = hydrate(_SCHEMA_REASONING_CONTENT_BLOCK).members_by_index - return cls(value=deserializer.read_blob(members[1])) + return cls( + value=deserializer.read_blob( + _SCHEMA_REASONING_CONTENT_BLOCK.members["redactedContent"] + ) + ) @dataclass @@ -9358,9 +10230,7 @@ class _ReasoningContentBlockDeserializer: def deserialize(self, deserializer: ShapeDeserializer) -> ReasoningContentBlock: self._result = None - deserializer.read_struct( - hydrate(_SCHEMA_REASONING_CONTENT_BLOCK), self._consumer - ) + deserializer.read_struct(_SCHEMA_REASONING_CONTENT_BLOCK, self._consumer) if self._result is None: raise SerializationError( @@ -9398,11 +10268,12 @@ class SearchResultContentBlock: """The actual text content""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_SEARCH_RESULT_CONTENT_BLOCK), self) + serializer.write_struct(_SCHEMA_SEARCH_RESULT_CONTENT_BLOCK, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_SEARCH_RESULT_CONTENT_BLOCK).members_by_index - serializer.write_string(members[0], self.text) + serializer.write_string( + _SCHEMA_SEARCH_RESULT_CONTENT_BLOCK.members["text"], self.text + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -9411,18 +10282,20 @@ 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(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: - kwargs["text"] = de.read_string(members[0]) + kwargs["text"] = de.read_string( + _SCHEMA_SEARCH_RESULT_CONTENT_BLOCK.members["text"] + ) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct( + _SCHEMA_SEARCH_RESULT_CONTENT_BLOCK, consumer=_consumer + ) if "text" not in kwargs: kwargs["text"] = "" return kwargs @@ -9431,7 +10304,7 @@ def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: def _serialize_search_result_content_blocks( serializer: ShapeSerializer, schema: Schema, value: list[SearchResultContentBlock] ) -> None: - member_schema = schema.members_by_index[0] + member_schema = schema.members["member"] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_struct(member_schema, e) @@ -9477,15 +10350,22 @@ class SearchResultBlock: """Configuration setting for citations""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_SEARCH_RESULT_BLOCK), self) + serializer.write_struct(_SCHEMA_SEARCH_RESULT_BLOCK, self) def serialize_members(self, serializer: ShapeSerializer): - 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) + 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 + ) if self.citations is not None: - serializer.write_struct(members[3], self.citations) + serializer.write_struct( + _SCHEMA_SEARCH_RESULT_BLOCK.members["citations"], self.citations + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -9494,29 +10374,31 @@ 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(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: - kwargs["source"] = de.read_string(members[0]) + kwargs["source"] = de.read_string( + _SCHEMA_SEARCH_RESULT_BLOCK.members["source"] + ) case 1: - kwargs["title"] = de.read_string(members[1]) + kwargs["title"] = de.read_string( + _SCHEMA_SEARCH_RESULT_BLOCK.members["title"] + ) case 2: kwargs["content"] = _deserialize_search_result_content_blocks( - de, members[2] + de, _SCHEMA_SEARCH_RESULT_BLOCK.members["content"] ) case 3: kwargs["citations"] = CitationsConfig.deserialize(de) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct(_SCHEMA_SEARCH_RESULT_BLOCK, consumer=_consumer) if "source" not in kwargs: kwargs["source"] = "" if "title" not in kwargs: @@ -9550,18 +10432,19 @@ class ToolReference: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_TOOL_REFERENCE), self) + serializer.write_struct(_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(members[0], self.type) + serializer.write_string(_SCHEMA_TOOL_REFERENCE.members["type"], self.type) if self.name is not None: - serializer.write_string(members[1], self.name) + serializer.write_string(_SCHEMA_TOOL_REFERENCE.members["name"], self.name) if self.server_name is not None: - serializer.write_string(members[2], self.server_name) + serializer.write_string( + _SCHEMA_TOOL_REFERENCE.members["serverName"], self.server_name + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -9570,24 +10453,28 @@ 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(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: - kwargs["type"] = de.read_string(members[0]) + kwargs["type"] = de.read_string( + _SCHEMA_TOOL_REFERENCE.members["type"] + ) case 1: - kwargs["name"] = de.read_string(members[1]) + kwargs["name"] = de.read_string( + _SCHEMA_TOOL_REFERENCE.members["name"] + ) case 2: - kwargs["server_name"] = de.read_string(members[2]) + kwargs["server_name"] = de.read_string( + _SCHEMA_TOOL_REFERENCE.members["serverName"] + ) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct(_SCHEMA_TOOL_REFERENCE, consumer=_consumer) return kwargs @classmethod @@ -9608,11 +10495,10 @@ class ToolAdditionBlock: """A reference to the tool to add to the available tool set.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_TOOL_ADDITION_BLOCK), self) + serializer.write_struct(_SCHEMA_TOOL_ADDITION_BLOCK, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_TOOL_ADDITION_BLOCK).members_by_index - serializer.write_struct(members[0], self.tool) + serializer.write_struct(_SCHEMA_TOOL_ADDITION_BLOCK.members["tool"], self.tool) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -9621,18 +10507,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_ADDITION_BLOCK) - members = schema.members_by_index - def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: kwargs["tool"] = ToolReference.deserialize(de) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct(_SCHEMA_TOOL_ADDITION_BLOCK, consumer=_consumer) if "tool" not in kwargs: kwargs["tool"] = ToolReference._smithy_default() return kwargs @@ -9651,11 +10535,10 @@ class ToolRemovalBlock: """A reference to the tool to remove from the available tool set.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_TOOL_REMOVAL_BLOCK), self) + serializer.write_struct(_SCHEMA_TOOL_REMOVAL_BLOCK, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_TOOL_REMOVAL_BLOCK).members_by_index - serializer.write_struct(members[0], self.tool) + serializer.write_struct(_SCHEMA_TOOL_REMOVAL_BLOCK.members["tool"], self.tool) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -9664,18 +10547,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_REMOVAL_BLOCK) - members = schema.members_by_index - def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: kwargs["tool"] = ToolReference.deserialize(de) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct(_SCHEMA_TOOL_REMOVAL_BLOCK, consumer=_consumer) if "tool" not in kwargs: kwargs["tool"] = ToolReference._smithy_default() return kwargs @@ -9700,16 +10581,14 @@ class VideoSourceBytes: value: bytes def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_VIDEO_SOURCE), self) + serializer.write_struct(_SCHEMA_VIDEO_SOURCE, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_VIDEO_SOURCE).members_by_index - serializer.write_blob(members[0], self.value) + serializer.write_blob(_SCHEMA_VIDEO_SOURCE.members["bytes"], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: - members = hydrate(_SCHEMA_VIDEO_SOURCE).members_by_index - return cls(value=deserializer.read_blob(members[0])) + return cls(value=deserializer.read_blob(_SCHEMA_VIDEO_SOURCE.members["bytes"])) @dataclass @@ -9723,11 +10602,10 @@ class VideoSourceS3Location: value: S3Location def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_VIDEO_SOURCE), self) + serializer.write_struct(_SCHEMA_VIDEO_SOURCE, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_VIDEO_SOURCE).members_by_index - serializer.write_struct(members[1], self.value) + serializer.write_struct(_SCHEMA_VIDEO_SOURCE.members["s3Location"], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -9771,7 +10649,7 @@ class _VideoSourceDeserializer: def deserialize(self, deserializer: ShapeDeserializer) -> VideoSource: self._result = None - deserializer.read_struct(hydrate(_SCHEMA_VIDEO_SOURCE), self._consumer) + deserializer.read_struct(_SCHEMA_VIDEO_SOURCE, self._consumer) if self._result is None: raise SerializationError( @@ -9810,12 +10688,11 @@ class VideoBlock: """The block's source.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_VIDEO_BLOCK), self) + serializer.write_struct(_SCHEMA_VIDEO_BLOCK, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_VIDEO_BLOCK).members_by_index - serializer.write_string(members[0], self.format) - serializer.write_struct(members[1], self.source) + serializer.write_string(_SCHEMA_VIDEO_BLOCK.members["format"], self.format) + serializer.write_struct(_SCHEMA_VIDEO_BLOCK.members["source"], self.source) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -9824,21 +10701,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(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: - kwargs["format"] = VideoFormat(de.read_string(members[0])) + kwargs["format"] = VideoFormat( + de.read_string(_SCHEMA_VIDEO_BLOCK.members["format"]) + ) case 1: kwargs["source"] = _VideoSourceDeserializer().deserialize(de) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct(_SCHEMA_VIDEO_BLOCK, consumer=_consumer) if "format" not in kwargs: kwargs["format"] = VideoFormat._corrected("") if "source" not in kwargs: @@ -9853,16 +10730,20 @@ class ToolResultContentBlockJson: value: Document def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_TOOL_RESULT_CONTENT_BLOCK), self) + serializer.write_struct(_SCHEMA_TOOL_RESULT_CONTENT_BLOCK, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_TOOL_RESULT_CONTENT_BLOCK).members_by_index - serializer.write_document(members[0], self.value) + serializer.write_document( + _SCHEMA_TOOL_RESULT_CONTENT_BLOCK.members["json"], self.value + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: - members = hydrate(_SCHEMA_TOOL_RESULT_CONTENT_BLOCK).members_by_index - return cls(value=deserializer.read_document(members[0])) + return cls( + value=deserializer.read_document( + _SCHEMA_TOOL_RESULT_CONTENT_BLOCK.members["json"] + ) + ) @dataclass @@ -9872,16 +10753,20 @@ class ToolResultContentBlockText: value: str def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_TOOL_RESULT_CONTENT_BLOCK), self) + serializer.write_struct(_SCHEMA_TOOL_RESULT_CONTENT_BLOCK, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_TOOL_RESULT_CONTENT_BLOCK).members_by_index - serializer.write_string(members[1], self.value) + serializer.write_string( + _SCHEMA_TOOL_RESULT_CONTENT_BLOCK.members["text"], self.value + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: - members = hydrate(_SCHEMA_TOOL_RESULT_CONTENT_BLOCK).members_by_index - return cls(value=deserializer.read_string(members[1])) + return cls( + value=deserializer.read_string( + _SCHEMA_TOOL_RESULT_CONTENT_BLOCK.members["text"] + ) + ) @dataclass @@ -9897,11 +10782,12 @@ class ToolResultContentBlockImage: value: ImageBlock def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_TOOL_RESULT_CONTENT_BLOCK), self) + serializer.write_struct(_SCHEMA_TOOL_RESULT_CONTENT_BLOCK, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_TOOL_RESULT_CONTENT_BLOCK).members_by_index - serializer.write_struct(members[2], self.value) + serializer.write_struct( + _SCHEMA_TOOL_RESULT_CONTENT_BLOCK.members["image"], self.value + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -9915,11 +10801,12 @@ class ToolResultContentBlockDocument: value: DocumentBlock def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_TOOL_RESULT_CONTENT_BLOCK), self) + serializer.write_struct(_SCHEMA_TOOL_RESULT_CONTENT_BLOCK, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_TOOL_RESULT_CONTENT_BLOCK).members_by_index - serializer.write_struct(members[3], self.value) + serializer.write_struct( + _SCHEMA_TOOL_RESULT_CONTENT_BLOCK.members["document"], self.value + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -9933,11 +10820,12 @@ class ToolResultContentBlockVideo: value: VideoBlock def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_TOOL_RESULT_CONTENT_BLOCK), self) + serializer.write_struct(_SCHEMA_TOOL_RESULT_CONTENT_BLOCK, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_TOOL_RESULT_CONTENT_BLOCK).members_by_index - serializer.write_struct(members[4], self.value) + serializer.write_struct( + _SCHEMA_TOOL_RESULT_CONTENT_BLOCK.members["video"], self.value + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -9951,11 +10839,12 @@ class ToolResultContentBlockSearchResult: value: SearchResultBlock def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_TOOL_RESULT_CONTENT_BLOCK), self) + serializer.write_struct(_SCHEMA_TOOL_RESULT_CONTENT_BLOCK, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_TOOL_RESULT_CONTENT_BLOCK).members_by_index - serializer.write_struct(members[5], self.value) + serializer.write_struct( + _SCHEMA_TOOL_RESULT_CONTENT_BLOCK.members["searchResult"], self.value + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -10008,9 +10897,7 @@ class _ToolResultContentBlockDeserializer: def deserialize(self, deserializer: ShapeDeserializer) -> ToolResultContentBlock: self._result = None - deserializer.read_struct( - hydrate(_SCHEMA_TOOL_RESULT_CONTENT_BLOCK), self._consumer - ) + deserializer.read_struct(_SCHEMA_TOOL_RESULT_CONTENT_BLOCK, self._consumer) if self._result is None: raise SerializationError( @@ -10055,7 +10942,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_by_index[0] + member_schema = schema.members["member"] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_struct(member_schema, e) @@ -10111,17 +10998,24 @@ class ToolResultBlock: """The type for the tool result content block.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_TOOL_RESULT_BLOCK), self) + serializer.write_struct(_SCHEMA_TOOL_RESULT_BLOCK, self) def serialize_members(self, serializer: ShapeSerializer): - 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) + 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 + ) if self.status is not None: - serializer.write_string(members[2], self.status) + serializer.write_string( + _SCHEMA_TOOL_RESULT_BLOCK.members["status"], self.status + ) if self.type is not None: - serializer.write_string(members[3], self.type) + serializer.write_string( + _SCHEMA_TOOL_RESULT_BLOCK.members["type"], self.type + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -10130,29 +11024,33 @@ 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(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: - kwargs["tool_use_id"] = de.read_string(members[0]) + kwargs["tool_use_id"] = de.read_string( + _SCHEMA_TOOL_RESULT_BLOCK.members["toolUseId"] + ) case 1: kwargs["content"] = _deserialize_tool_result_content_blocks( - de, members[1] + de, _SCHEMA_TOOL_RESULT_BLOCK.members["content"] ) case 2: - kwargs["status"] = ToolResultStatus(de.read_string(members[2])) + kwargs["status"] = ToolResultStatus( + de.read_string(_SCHEMA_TOOL_RESULT_BLOCK.members["status"]) + ) case 3: - kwargs["type"] = de.read_string(members[3]) + kwargs["type"] = de.read_string( + _SCHEMA_TOOL_RESULT_BLOCK.members["type"] + ) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct(_SCHEMA_TOOL_RESULT_BLOCK, consumer=_consumer) if "tool_use_id" not in kwargs: kwargs["tool_use_id"] = "" if "content" not in kwargs: @@ -10188,15 +11086,16 @@ class ToolUseBlock: """The type for the tool request.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_TOOL_USE_BLOCK), self) + serializer.write_struct(_SCHEMA_TOOL_USE_BLOCK, self) def serialize_members(self, serializer: ShapeSerializer): - 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) + 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) if self.type is not None: - serializer.write_string(members[3], self.type) + serializer.write_string(_SCHEMA_TOOL_USE_BLOCK.members["type"], self.type) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -10205,27 +11104,33 @@ 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(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: - kwargs["tool_use_id"] = de.read_string(members[0]) + kwargs["tool_use_id"] = de.read_string( + _SCHEMA_TOOL_USE_BLOCK.members["toolUseId"] + ) case 1: - kwargs["name"] = de.read_string(members[1]) + kwargs["name"] = de.read_string( + _SCHEMA_TOOL_USE_BLOCK.members["name"] + ) case 2: - kwargs["input"] = de.read_document(members[2]) + kwargs["input"] = de.read_document( + _SCHEMA_TOOL_USE_BLOCK.members["input"] + ) case 3: - kwargs["type"] = ToolUseType(de.read_string(members[3])) + kwargs["type"] = ToolUseType( + de.read_string(_SCHEMA_TOOL_USE_BLOCK.members["type"]) + ) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct(_SCHEMA_TOOL_USE_BLOCK, consumer=_consumer) if "tool_use_id" not in kwargs: kwargs["tool_use_id"] = "" if "name" not in kwargs: @@ -10242,16 +11147,16 @@ class ContentBlockText: value: str def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_CONTENT_BLOCK), self) + serializer.write_struct(_SCHEMA_CONTENT_BLOCK, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_CONTENT_BLOCK).members_by_index - serializer.write_string(members[0], self.value) + serializer.write_string(_SCHEMA_CONTENT_BLOCK.members["text"], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: - members = hydrate(_SCHEMA_CONTENT_BLOCK).members_by_index - return cls(value=deserializer.read_string(members[0])) + return cls( + value=deserializer.read_string(_SCHEMA_CONTENT_BLOCK.members["text"]) + ) @dataclass @@ -10266,11 +11171,10 @@ class ContentBlockImage: value: ImageBlock def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_CONTENT_BLOCK), self) + serializer.write_struct(_SCHEMA_CONTENT_BLOCK, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_CONTENT_BLOCK).members_by_index - serializer.write_struct(members[1], self.value) + serializer.write_struct(_SCHEMA_CONTENT_BLOCK.members["image"], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -10284,11 +11188,10 @@ class ContentBlockDocument: value: DocumentBlock def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_CONTENT_BLOCK), self) + serializer.write_struct(_SCHEMA_CONTENT_BLOCK, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_CONTENT_BLOCK).members_by_index - serializer.write_struct(members[2], self.value) + serializer.write_struct(_SCHEMA_CONTENT_BLOCK.members["document"], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -10302,11 +11205,10 @@ class ContentBlockVideo: value: VideoBlock def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_CONTENT_BLOCK), self) + serializer.write_struct(_SCHEMA_CONTENT_BLOCK, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_CONTENT_BLOCK).members_by_index - serializer.write_struct(members[3], self.value) + serializer.write_struct(_SCHEMA_CONTENT_BLOCK.members["video"], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -10320,11 +11222,10 @@ class ContentBlockAudio: value: AudioBlock def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_CONTENT_BLOCK), self) + serializer.write_struct(_SCHEMA_CONTENT_BLOCK, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_CONTENT_BLOCK).members_by_index - serializer.write_struct(members[4], self.value) + serializer.write_struct(_SCHEMA_CONTENT_BLOCK.members["audio"], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -10338,11 +11239,10 @@ class ContentBlockToolUse: value: ToolUseBlock def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_CONTENT_BLOCK), self) + serializer.write_struct(_SCHEMA_CONTENT_BLOCK, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_CONTENT_BLOCK).members_by_index - serializer.write_struct(members[5], self.value) + serializer.write_struct(_SCHEMA_CONTENT_BLOCK.members["toolUse"], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -10356,11 +11256,10 @@ class ContentBlockToolResult: value: ToolResultBlock def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_CONTENT_BLOCK), self) + serializer.write_struct(_SCHEMA_CONTENT_BLOCK, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_CONTENT_BLOCK).members_by_index - serializer.write_struct(members[6], self.value) + serializer.write_struct(_SCHEMA_CONTENT_BLOCK.members["toolResult"], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -10381,11 +11280,12 @@ class ContentBlockGuardContent: value: GuardrailConverseContentBlock def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_CONTENT_BLOCK), self) + serializer.write_struct(_SCHEMA_CONTENT_BLOCK, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_CONTENT_BLOCK).members_by_index - serializer.write_struct(members[7], self.value) + serializer.write_struct( + _SCHEMA_CONTENT_BLOCK.members["guardContent"], self.value + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -10401,11 +11301,10 @@ class ContentBlockCachePoint: value: CachePointBlock def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_CONTENT_BLOCK), self) + serializer.write_struct(_SCHEMA_CONTENT_BLOCK, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_CONTENT_BLOCK).members_by_index - serializer.write_struct(members[8], self.value) + serializer.write_struct(_SCHEMA_CONTENT_BLOCK.members["cachePoint"], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -10423,11 +11322,12 @@ class ContentBlockReasoningContent: value: ReasoningContentBlock def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_CONTENT_BLOCK), self) + serializer.write_struct(_SCHEMA_CONTENT_BLOCK, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_CONTENT_BLOCK).members_by_index - serializer.write_struct(members[9], self.value) + serializer.write_struct( + _SCHEMA_CONTENT_BLOCK.members["reasoningContent"], self.value + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -10445,11 +11345,12 @@ class ContentBlockCitationsContent: value: CitationsContentBlock def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_CONTENT_BLOCK), self) + serializer.write_struct(_SCHEMA_CONTENT_BLOCK, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_CONTENT_BLOCK).members_by_index - serializer.write_struct(members[10], self.value) + serializer.write_struct( + _SCHEMA_CONTENT_BLOCK.members["citationsContent"], self.value + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -10463,11 +11364,12 @@ class ContentBlockSearchResult: value: SearchResultBlock def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_CONTENT_BLOCK), self) + serializer.write_struct(_SCHEMA_CONTENT_BLOCK, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_CONTENT_BLOCK).members_by_index - serializer.write_struct(members[11], self.value) + serializer.write_struct( + _SCHEMA_CONTENT_BLOCK.members["searchResult"], self.value + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -10486,11 +11388,12 @@ class ContentBlockToolAddition: value: ToolAdditionBlock def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_CONTENT_BLOCK), self) + serializer.write_struct(_SCHEMA_CONTENT_BLOCK, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_CONTENT_BLOCK).members_by_index - serializer.write_struct(members[12], self.value) + serializer.write_struct( + _SCHEMA_CONTENT_BLOCK.members["toolAddition"], self.value + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -10509,11 +11412,12 @@ class ContentBlockToolRemoval: value: ToolRemovalBlock def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_CONTENT_BLOCK), self) + serializer.write_struct(_SCHEMA_CONTENT_BLOCK, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_CONTENT_BLOCK).members_by_index - serializer.write_struct(members[13], self.value) + serializer.write_struct( + _SCHEMA_CONTENT_BLOCK.members["toolRemoval"], self.value + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -10576,7 +11480,7 @@ class _ContentBlockDeserializer: def deserialize(self, deserializer: ShapeDeserializer) -> ContentBlock: self._result = None - deserializer.read_struct(hydrate(_SCHEMA_CONTENT_BLOCK), self._consumer) + deserializer.read_struct(_SCHEMA_CONTENT_BLOCK, self._consumer) if self._result is None: raise SerializationError( @@ -10643,7 +11547,7 @@ def _set_result(self, value: ContentBlock) -> None: def _serialize_content_blocks( serializer: ShapeSerializer, schema: Schema, value: list[ContentBlock] ) -> None: - member_schema = schema.members_by_index[0] + member_schema = schema.members["member"] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_struct(member_schema, e) @@ -10700,12 +11604,13 @@ class Message: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_MESSAGE), self) + serializer.write_struct(_SCHEMA_MESSAGE, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_MESSAGE).members_by_index - serializer.write_string(members[0], self.role) - _serialize_content_blocks(serializer, members[1], self.content) + serializer.write_string(_SCHEMA_MESSAGE.members["role"], self.role) + _serialize_content_blocks( + serializer, _SCHEMA_MESSAGE.members["content"], self.content + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -10714,21 +11619,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) - members = schema.members_by_index - def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: - kwargs["role"] = ConversationRole(de.read_string(members[0])) + kwargs["role"] = ConversationRole( + de.read_string(_SCHEMA_MESSAGE.members["role"]) + ) case 1: - kwargs["content"] = _deserialize_content_blocks(de, members[1]) + kwargs["content"] = _deserialize_content_blocks( + de, _SCHEMA_MESSAGE.members["content"] + ) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct(_SCHEMA_MESSAGE, consumer=_consumer) if "role" not in kwargs: kwargs["role"] = ConversationRole._corrected("") if "content" not in kwargs: @@ -10739,7 +11646,7 @@ def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: def _serialize_messages( serializer: ShapeSerializer, schema: Schema, value: list[Message] ) -> None: - member_schema = schema.members_by_index[0] + member_schema = schema.members["member"] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_struct(member_schema, e) @@ -10779,16 +11686,21 @@ class JsonSchemaDefinition: """A description of the JSON schema.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_JSON_SCHEMA_DEFINITION), self) + serializer.write_struct(_SCHEMA_JSON_SCHEMA_DEFINITION, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_JSON_SCHEMA_DEFINITION).members_by_index - serializer.write_string(members[0], self.schema) + serializer.write_string( + _SCHEMA_JSON_SCHEMA_DEFINITION.members["schema"], self.schema + ) if self.name is not None: - serializer.write_string(members[1], self.name) + serializer.write_string( + _SCHEMA_JSON_SCHEMA_DEFINITION.members["name"], self.name + ) if self.description is not None: - serializer.write_string(members[2], self.description) + serializer.write_string( + _SCHEMA_JSON_SCHEMA_DEFINITION.members["description"], self.description + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -10797,24 +11709,28 @@ 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(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: - kwargs["schema"] = de.read_string(members[0]) + kwargs["schema"] = de.read_string( + _SCHEMA_JSON_SCHEMA_DEFINITION.members["schema"] + ) case 1: - kwargs["name"] = de.read_string(members[1]) + kwargs["name"] = de.read_string( + _SCHEMA_JSON_SCHEMA_DEFINITION.members["name"] + ) case 2: - kwargs["description"] = de.read_string(members[2]) + kwargs["description"] = de.read_string( + _SCHEMA_JSON_SCHEMA_DEFINITION.members["description"] + ) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct(_SCHEMA_JSON_SCHEMA_DEFINITION, consumer=_consumer) if "schema" not in kwargs: kwargs["schema"] = "" return kwargs @@ -10827,11 +11743,12 @@ class OutputFormatStructureJsonSchema: value: JsonSchemaDefinition def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_OUTPUT_FORMAT_STRUCTURE), self) + serializer.write_struct(_SCHEMA_OUTPUT_FORMAT_STRUCTURE, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_OUTPUT_FORMAT_STRUCTURE).members_by_index - serializer.write_struct(members[0], self.value) + serializer.write_struct( + _SCHEMA_OUTPUT_FORMAT_STRUCTURE.members["jsonSchema"], self.value + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -10873,9 +11790,7 @@ class _OutputFormatStructureDeserializer: def deserialize(self, deserializer: ShapeDeserializer) -> OutputFormatStructure: self._result = None - deserializer.read_struct( - hydrate(_SCHEMA_OUTPUT_FORMAT_STRUCTURE), self._consumer - ) + deserializer.read_struct(_SCHEMA_OUTPUT_FORMAT_STRUCTURE, self._consumer) if self._result is None: raise SerializationError( @@ -10922,12 +11837,13 @@ class OutputFormat: """The structure that the model's output must adhere to.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_OUTPUT_FORMAT), self) + serializer.write_struct(_SCHEMA_OUTPUT_FORMAT, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_OUTPUT_FORMAT).members_by_index - serializer.write_string(members[0], self.type) - serializer.write_struct(members[1], self.structure) + serializer.write_string(_SCHEMA_OUTPUT_FORMAT.members["type"], self.type) + serializer.write_struct( + _SCHEMA_OUTPUT_FORMAT.members["structure"], self.structure + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -10936,13 +11852,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(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: - kwargs["type"] = OutputFormatType(de.read_string(members[0])) + kwargs["type"] = OutputFormatType( + de.read_string(_SCHEMA_OUTPUT_FORMAT.members["type"]) + ) case 1: kwargs["structure"] = ( @@ -10950,9 +11866,9 @@ def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: ) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct(_SCHEMA_OUTPUT_FORMAT, consumer=_consumer) if "type" not in kwargs: kwargs["type"] = OutputFormatType._corrected("") if "structure" not in kwargs: @@ -10986,15 +11902,18 @@ class OutputConfig: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_OUTPUT_CONFIG), self) + serializer.write_struct(_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(members[0], self.text_format) + serializer.write_struct( + _SCHEMA_OUTPUT_CONFIG.members["textFormat"], self.text_format + ) if self.effort is not None: - serializer.write_string(members[1], self.effort) + serializer.write_string( + _SCHEMA_OUTPUT_CONFIG.members["effort"], self.effort + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -11003,21 +11922,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(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: kwargs["text_format"] = OutputFormat.deserialize(de) case 1: - kwargs["effort"] = de.read_string(members[1]) + kwargs["effort"] = de.read_string( + _SCHEMA_OUTPUT_CONFIG.members["effort"] + ) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct(_SCHEMA_OUTPUT_CONFIG, consumer=_consumer) return kwargs @@ -11034,11 +11953,12 @@ class PerformanceConfiguration: """To use a latency-optimized version of the model, set to `optimized`.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_PERFORMANCE_CONFIGURATION), self) + serializer.write_struct(_SCHEMA_PERFORMANCE_CONFIGURATION, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_PERFORMANCE_CONFIGURATION).members_by_index - serializer.write_string(members[0], self.latency) + serializer.write_string( + _SCHEMA_PERFORMANCE_CONFIGURATION.members["latency"], self.latency + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -11047,20 +11967,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(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: kwargs["latency"] = PerformanceConfigLatency( - de.read_string(members[0]) + de.read_string( + _SCHEMA_PERFORMANCE_CONFIGURATION.members["latency"] + ) ) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct(_SCHEMA_PERFORMANCE_CONFIGURATION, consumer=_consumer) return kwargs @@ -11071,16 +11991,20 @@ class PromptVariableValuesText: value: str def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_PROMPT_VARIABLE_VALUES), self) + serializer.write_struct(_SCHEMA_PROMPT_VARIABLE_VALUES, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_PROMPT_VARIABLE_VALUES).members_by_index - serializer.write_string(members[0], self.value) + serializer.write_string( + _SCHEMA_PROMPT_VARIABLE_VALUES.members["text"], self.value + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: - members = hydrate(_SCHEMA_PROMPT_VARIABLE_VALUES).members_by_index - return cls(value=deserializer.read_string(members[0])) + return cls( + value=deserializer.read_string( + _SCHEMA_PROMPT_VARIABLE_VALUES.members["text"] + ) + ) @dataclass @@ -11121,9 +12045,7 @@ class _PromptVariableValuesDeserializer: def deserialize(self, deserializer: ShapeDeserializer) -> PromptVariableValues: self._result = None - deserializer.read_struct( - hydrate(_SCHEMA_PROMPT_VARIABLE_VALUES), self._consumer - ) + deserializer.read_struct(_SCHEMA_PROMPT_VARIABLE_VALUES, self._consumer) if self._result is None: raise SerializationError( @@ -11154,7 +12076,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_by_index[1] + value_schema = schema.members["value"] for k, v in value.items(): m.entry(k, lambda vs: vs.write_struct(value_schema, v)) @@ -11163,7 +12085,7 @@ def _deserialize_prompt_variable_map( deserializer: ShapeDeserializer, schema: Schema ) -> dict[str, PromptVariableValues]: result: dict[str, PromptVariableValues] = {} - value_schema = schema.members_by_index[1] + value_schema = schema.members["value"] def _read_value(k: str, d: ShapeDeserializer): if d.is_null(): @@ -11180,7 +12102,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_by_index[1] + value_schema = schema.members["value"] for k, v in value.items(): m.entry(k, lambda vs: vs.write_string(value_schema, v)) @@ -11189,7 +12111,7 @@ def _deserialize_request_metadata( deserializer: ShapeDeserializer, schema: Schema ) -> dict[str, str]: result: dict[str, str] = {} - value_schema = schema.members_by_index[1] + value_schema = schema.members["value"] def _read_value(k: str, d: ShapeDeserializer): if d.is_null(): @@ -11220,11 +12142,10 @@ class ServiceTier: """Specifies the processing tier type used for serving the request.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_SERVICE_TIER), self) + serializer.write_struct(_SCHEMA_SERVICE_TIER, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_SERVICE_TIER).members_by_index - serializer.write_string(members[0], self.type) + serializer.write_string(_SCHEMA_SERVICE_TIER.members["type"], self.type) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -11233,18 +12154,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(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: - kwargs["type"] = ServiceTierType(de.read_string(members[0])) + kwargs["type"] = ServiceTierType( + de.read_string(_SCHEMA_SERVICE_TIER.members["type"]) + ) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct(_SCHEMA_SERVICE_TIER, consumer=_consumer) if "type" not in kwargs: kwargs["type"] = ServiceTierType._corrected("") return kwargs @@ -11257,16 +12178,18 @@ class SystemContentBlockText: value: str def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_SYSTEM_CONTENT_BLOCK), self) + serializer.write_struct(_SCHEMA_SYSTEM_CONTENT_BLOCK, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_SYSTEM_CONTENT_BLOCK).members_by_index - serializer.write_string(members[0], self.value) + serializer.write_string( + _SCHEMA_SYSTEM_CONTENT_BLOCK.members["text"], self.value + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: - members = hydrate(_SCHEMA_SYSTEM_CONTENT_BLOCK).members_by_index - return cls(value=deserializer.read_string(members[0])) + return cls( + value=deserializer.read_string(_SCHEMA_SYSTEM_CONTENT_BLOCK.members["text"]) + ) @dataclass @@ -11285,11 +12208,12 @@ class SystemContentBlockGuardContent: value: GuardrailConverseContentBlock def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_SYSTEM_CONTENT_BLOCK), self) + serializer.write_struct(_SCHEMA_SYSTEM_CONTENT_BLOCK, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_SYSTEM_CONTENT_BLOCK).members_by_index - serializer.write_struct(members[1], self.value) + serializer.write_struct( + _SCHEMA_SYSTEM_CONTENT_BLOCK.members["guardContent"], self.value + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -11305,11 +12229,12 @@ class SystemContentBlockCachePoint: value: CachePointBlock def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_SYSTEM_CONTENT_BLOCK), self) + serializer.write_struct(_SCHEMA_SYSTEM_CONTENT_BLOCK, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_SYSTEM_CONTENT_BLOCK).members_by_index - serializer.write_struct(members[2], self.value) + serializer.write_struct( + _SCHEMA_SYSTEM_CONTENT_BLOCK.members["cachePoint"], self.value + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -11358,7 +12283,7 @@ class _SystemContentBlockDeserializer: def deserialize(self, deserializer: ShapeDeserializer) -> SystemContentBlock: self._result = None - deserializer.read_struct(hydrate(_SCHEMA_SYSTEM_CONTENT_BLOCK), self._consumer) + deserializer.read_struct(_SCHEMA_SYSTEM_CONTENT_BLOCK, self._consumer) if self._result is None: raise SerializationError( @@ -11394,7 +12319,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_by_index[0] + member_schema = schema.members["member"] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_struct(member_schema, e) @@ -11427,7 +12352,7 @@ class AnyToolChoice: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_ANY_TOOL_CHOICE), self) + serializer.write_struct(_SCHEMA_ANY_TOOL_CHOICE, self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -11439,14 +12364,13 @@ 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(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct(_SCHEMA_ANY_TOOL_CHOICE, consumer=_consumer) return kwargs @@ -11461,7 +12385,7 @@ class AutoToolChoice: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_AUTO_TOOL_CHOICE), self) + serializer.write_struct(_SCHEMA_AUTO_TOOL_CHOICE, self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -11473,14 +12397,13 @@ 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(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct(_SCHEMA_AUTO_TOOL_CHOICE, consumer=_consumer) return kwargs @@ -11501,11 +12424,10 @@ class SpecificToolChoice: """The name of the tool that the model must request.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_SPECIFIC_TOOL_CHOICE), self) + serializer.write_struct(_SCHEMA_SPECIFIC_TOOL_CHOICE, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_SPECIFIC_TOOL_CHOICE).members_by_index - serializer.write_string(members[0], self.name) + serializer.write_string(_SCHEMA_SPECIFIC_TOOL_CHOICE.members["name"], self.name) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -11514,18 +12436,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(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: - kwargs["name"] = de.read_string(members[0]) + kwargs["name"] = de.read_string( + _SCHEMA_SPECIFIC_TOOL_CHOICE.members["name"] + ) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct(_SCHEMA_SPECIFIC_TOOL_CHOICE, consumer=_consumer) if "name" not in kwargs: kwargs["name"] = "" return kwargs @@ -11541,11 +12463,10 @@ class ToolChoiceAuto: value: AutoToolChoice def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_TOOL_CHOICE), self) + serializer.write_struct(_SCHEMA_TOOL_CHOICE, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_TOOL_CHOICE).members_by_index - serializer.write_struct(members[0], self.value) + serializer.write_struct(_SCHEMA_TOOL_CHOICE.members["auto"], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -11559,11 +12480,10 @@ class ToolChoiceAny: value: AnyToolChoice def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_TOOL_CHOICE), self) + serializer.write_struct(_SCHEMA_TOOL_CHOICE, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_TOOL_CHOICE).members_by_index - serializer.write_struct(members[1], self.value) + serializer.write_struct(_SCHEMA_TOOL_CHOICE.members["any"], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -11580,11 +12500,10 @@ class ToolChoiceTool: value: SpecificToolChoice def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_TOOL_CHOICE), self) + serializer.write_struct(_SCHEMA_TOOL_CHOICE, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_TOOL_CHOICE).members_by_index - serializer.write_struct(members[2], self.value) + serializer.write_struct(_SCHEMA_TOOL_CHOICE.members["tool"], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -11630,7 +12549,7 @@ class _ToolChoiceDeserializer: def deserialize(self, deserializer: ShapeDeserializer) -> ToolChoice: self._result = None - deserializer.read_struct(hydrate(_SCHEMA_TOOL_CHOICE), self._consumer) + deserializer.read_struct(_SCHEMA_TOOL_CHOICE, self._consumer) if self._result is None: raise SerializationError( @@ -11672,11 +12591,10 @@ class SystemTool: """The name of the system-defined tool that you want to call.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_SYSTEM_TOOL), self) + serializer.write_struct(_SCHEMA_SYSTEM_TOOL, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_SYSTEM_TOOL).members_by_index - serializer.write_string(members[0], self.name) + serializer.write_string(_SCHEMA_SYSTEM_TOOL.members["name"], self.name) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -11685,18 +12603,16 @@ 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(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: - kwargs["name"] = de.read_string(members[0]) + kwargs["name"] = de.read_string(_SCHEMA_SYSTEM_TOOL.members["name"]) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct(_SCHEMA_SYSTEM_TOOL, consumer=_consumer) if "name" not in kwargs: kwargs["name"] = "" return kwargs @@ -11712,16 +12628,16 @@ class ToolInputSchemaJson: value: Document def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_TOOL_INPUT_SCHEMA), self) + serializer.write_struct(_SCHEMA_TOOL_INPUT_SCHEMA, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_TOOL_INPUT_SCHEMA).members_by_index - serializer.write_document(members[0], self.value) + serializer.write_document(_SCHEMA_TOOL_INPUT_SCHEMA.members["json"], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: - members = hydrate(_SCHEMA_TOOL_INPUT_SCHEMA).members_by_index - return cls(value=deserializer.read_document(members[0])) + return cls( + value=deserializer.read_document(_SCHEMA_TOOL_INPUT_SCHEMA.members["json"]) + ) @dataclass @@ -11762,7 +12678,7 @@ class _ToolInputSchemaDeserializer: def deserialize(self, deserializer: ShapeDeserializer) -> ToolInputSchema: self._result = None - deserializer.read_struct(hydrate(_SCHEMA_TOOL_INPUT_SCHEMA), self._consumer) + deserializer.read_struct(_SCHEMA_TOOL_INPUT_SCHEMA, self._consumer) if self._result is None: raise SerializationError( @@ -11811,17 +12727,22 @@ class ToolSpecification: """Flag to enable structured output enforcement on a tool usage response.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_TOOL_SPECIFICATION), self) + serializer.write_struct(_SCHEMA_TOOL_SPECIFICATION, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_TOOL_SPECIFICATION).members_by_index - serializer.write_string(members[0], self.name) + serializer.write_string(_SCHEMA_TOOL_SPECIFICATION.members["name"], self.name) if self.description is not None: - serializer.write_string(members[1], self.description) + serializer.write_string( + _SCHEMA_TOOL_SPECIFICATION.members["description"], self.description + ) - serializer.write_struct(members[2], self.input_schema) + serializer.write_struct( + _SCHEMA_TOOL_SPECIFICATION.members["inputSchema"], self.input_schema + ) if self.strict is not None: - serializer.write_boolean(members[3], self.strict) + serializer.write_boolean( + _SCHEMA_TOOL_SPECIFICATION.members["strict"], self.strict + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -11830,16 +12751,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_SPECIFICATION) - members = schema.members_by_index - def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: - kwargs["name"] = de.read_string(members[0]) + kwargs["name"] = de.read_string( + _SCHEMA_TOOL_SPECIFICATION.members["name"] + ) case 1: - kwargs["description"] = de.read_string(members[1]) + kwargs["description"] = de.read_string( + _SCHEMA_TOOL_SPECIFICATION.members["description"] + ) case 2: kwargs["input_schema"] = _ToolInputSchemaDeserializer().deserialize( @@ -11847,12 +12770,14 @@ def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: ) case 3: - kwargs["strict"] = de.read_boolean(members[3]) + kwargs["strict"] = de.read_boolean( + _SCHEMA_TOOL_SPECIFICATION.members["strict"] + ) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct(_SCHEMA_TOOL_SPECIFICATION, consumer=_consumer) if "name" not in kwargs: kwargs["name"] = "" if "input_schema" not in kwargs: @@ -11867,11 +12792,10 @@ class ToolToolSpec: value: ToolSpecification def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_TOOL), self) + serializer.write_struct(_SCHEMA_TOOL, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_TOOL).members_by_index - serializer.write_struct(members[0], self.value) + serializer.write_struct(_SCHEMA_TOOL.members["toolSpec"], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -11885,11 +12809,10 @@ class ToolSystemTool: value: SystemTool def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_TOOL), self) + serializer.write_struct(_SCHEMA_TOOL, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_TOOL).members_by_index - serializer.write_struct(members[1], self.value) + serializer.write_struct(_SCHEMA_TOOL.members["systemTool"], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -11903,11 +12826,10 @@ class ToolCachePoint: value: CachePointBlock def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_TOOL), self) + serializer.write_struct(_SCHEMA_TOOL, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_TOOL).members_by_index - serializer.write_struct(members[2], self.value) + serializer.write_struct(_SCHEMA_TOOL.members["cachePoint"], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -11952,7 +12874,7 @@ class _ToolDeserializer: def deserialize(self, deserializer: ShapeDeserializer) -> Tool: self._result = None - deserializer.read_struct(hydrate(_SCHEMA_TOOL), self._consumer) + deserializer.read_struct(_SCHEMA_TOOL, self._consumer) if self._result is None: raise SerializationError( @@ -11986,7 +12908,7 @@ def _set_result(self, value: Tool) -> None: def _serialize_tools( serializer: ShapeSerializer, schema: Schema, value: list[Tool] ) -> None: - member_schema = schema.members_by_index[0] + member_schema = schema.members["member"] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_struct(member_schema, e) @@ -12022,13 +12944,16 @@ class ToolConfiguration: """If supported by model, forces the model to request a tool.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_TOOL_CONFIGURATION), self) + serializer.write_struct(_SCHEMA_TOOL_CONFIGURATION, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_TOOL_CONFIGURATION).members_by_index - _serialize_tools(serializer, members[0], self.tools) + _serialize_tools( + serializer, _SCHEMA_TOOL_CONFIGURATION.members["tools"], self.tools + ) if self.tool_choice is not None: - serializer.write_struct(members[1], self.tool_choice) + serializer.write_struct( + _SCHEMA_TOOL_CONFIGURATION.members["toolChoice"], self.tool_choice + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -12037,21 +12962,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(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: - kwargs["tools"] = _deserialize_tools(de, members[0]) + kwargs["tools"] = _deserialize_tools( + de, _SCHEMA_TOOL_CONFIGURATION.members["tools"] + ) case 1: kwargs["tool_choice"] = _ToolChoiceDeserializer().deserialize(de) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct(_SCHEMA_TOOL_CONFIGURATION, consumer=_consumer) if "tools" not in kwargs: kwargs["tools"] = [] return kwargs @@ -12189,52 +13114,81 @@ class ConverseInput: """Output configuration for a model response.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_CONVERSE_INPUT), self) + serializer.write_struct(_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(members[0], self.model_id) + serializer.write_string( + _SCHEMA_CONVERSE_INPUT.members["modelId"], self.model_id + ) if self.messages is not None: - _serialize_messages(serializer, members[1], self.messages) + _serialize_messages( + serializer, _SCHEMA_CONVERSE_INPUT.members["messages"], self.messages + ) if self.system is not None: - _serialize_system_content_blocks(serializer, members[2], self.system) + _serialize_system_content_blocks( + serializer, _SCHEMA_CONVERSE_INPUT.members["system"], self.system + ) if self.inference_config is not None: - serializer.write_struct(members[3], self.inference_config) + serializer.write_struct( + _SCHEMA_CONVERSE_INPUT.members["inferenceConfig"], self.inference_config + ) if self.tool_config is not None: - serializer.write_struct(members[4], self.tool_config) + serializer.write_struct( + _SCHEMA_CONVERSE_INPUT.members["toolConfig"], self.tool_config + ) if self.guardrail_config is not None: - serializer.write_struct(members[5], self.guardrail_config) + serializer.write_struct( + _SCHEMA_CONVERSE_INPUT.members["guardrailConfig"], self.guardrail_config + ) if self.additional_model_request_fields is not None: - serializer.write_document(members[6], self.additional_model_request_fields) + serializer.write_document( + _SCHEMA_CONVERSE_INPUT.members["additionalModelRequestFields"], + self.additional_model_request_fields, + ) if self.prompt_variables is not None: _serialize_prompt_variable_map( - serializer, members[7], self.prompt_variables + serializer, + _SCHEMA_CONVERSE_INPUT.members["promptVariables"], + self.prompt_variables, ) if self.additional_model_response_field_paths is not None: _serialize_additional_model_response_field_paths( - serializer, members[8], self.additional_model_response_field_paths + serializer, + _SCHEMA_CONVERSE_INPUT.members["additionalModelResponseFieldPaths"], + self.additional_model_response_field_paths, ) if self.request_metadata is not None: - _serialize_request_metadata(serializer, members[9], self.request_metadata) + _serialize_request_metadata( + serializer, + _SCHEMA_CONVERSE_INPUT.members["requestMetadata"], + self.request_metadata, + ) if self.performance_config is not None: - serializer.write_struct(members[10], self.performance_config) + serializer.write_struct( + _SCHEMA_CONVERSE_INPUT.members["performanceConfig"], + self.performance_config, + ) if self.service_tier is not None: - serializer.write_struct(members[11], self.service_tier) + serializer.write_struct( + _SCHEMA_CONVERSE_INPUT.members["serviceTier"], self.service_tier + ) if self.output_config is not None: - serializer.write_struct(members[12], self.output_config) + serializer.write_struct( + _SCHEMA_CONVERSE_INPUT.members["outputConfig"], self.output_config + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -12243,20 +13197,22 @@ 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(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: - kwargs["model_id"] = de.read_string(members[0]) + kwargs["model_id"] = de.read_string( + _SCHEMA_CONVERSE_INPUT.members["modelId"] + ) case 1: - kwargs["messages"] = _deserialize_messages(de, members[1]) + kwargs["messages"] = _deserialize_messages( + de, _SCHEMA_CONVERSE_INPUT.members["messages"] + ) case 2: kwargs["system"] = _deserialize_system_content_blocks( - de, members[2] + de, _SCHEMA_CONVERSE_INPUT.members["system"] ) case 3: @@ -12270,24 +13226,27 @@ def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: case 6: kwargs["additional_model_request_fields"] = de.read_document( - members[6] + _SCHEMA_CONVERSE_INPUT.members["additionalModelRequestFields"] ) case 7: kwargs["prompt_variables"] = _deserialize_prompt_variable_map( - de, members[7] + de, _SCHEMA_CONVERSE_INPUT.members["promptVariables"] ) case 8: kwargs["additional_model_response_field_paths"] = ( _deserialize_additional_model_response_field_paths( - de, members[8] + de, + _SCHEMA_CONVERSE_INPUT.members[ + "additionalModelResponseFieldPaths" + ], ) ) case 9: kwargs["request_metadata"] = _deserialize_request_metadata( - de, members[9] + de, _SCHEMA_CONVERSE_INPUT.members["requestMetadata"] ) case 10: @@ -12302,9 +13261,9 @@ def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: kwargs["output_config"] = OutputConfig.deserialize(de) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct(_SCHEMA_CONVERSE_INPUT, consumer=_consumer) return kwargs @@ -12319,11 +13278,12 @@ class ConverseMetrics: """The latency of the call to `Converse`, in milliseconds.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_CONVERSE_METRICS), self) + serializer.write_struct(_SCHEMA_CONVERSE_METRICS, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_CONVERSE_METRICS).members_by_index - serializer.write_long(members[0], self.latency_ms) + serializer.write_long( + _SCHEMA_CONVERSE_METRICS.members["latencyMs"], self.latency_ms + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -12332,18 +13292,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(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: - kwargs["latency_ms"] = de.read_long(members[0]) + kwargs["latency_ms"] = de.read_long( + _SCHEMA_CONVERSE_METRICS.members["latencyMs"] + ) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct(_SCHEMA_CONVERSE_METRICS, consumer=_consumer) if "latency_ms" not in kwargs: kwargs["latency_ms"] = 0 return kwargs @@ -12360,11 +13320,10 @@ class ConverseOutputMessage: value: Message def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_CONVERSE_OUTPUT), self) + serializer.write_struct(_SCHEMA_CONVERSE_OUTPUT, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_CONVERSE_OUTPUT).members_by_index - serializer.write_struct(members[0], self.value) + serializer.write_struct(_SCHEMA_CONVERSE_OUTPUT.members["message"], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -12407,7 +13366,7 @@ class _ConverseOutputDeserializer: def deserialize(self, deserializer: ShapeDeserializer) -> ConverseOutput: self._result = None - deserializer.read_struct(hydrate(_SCHEMA_CONVERSE_OUTPUT), self._consumer) + deserializer.read_struct(_SCHEMA_CONVERSE_OUTPUT, self._consumer) if self._result is None: raise SerializationError( @@ -12448,7 +13407,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_by_index[1] + value_schema = schema.members["value"] for k, v in value.items(): m.entry(k, lambda vs: vs.write_struct(value_schema, v)) @@ -12457,7 +13416,7 @@ def _deserialize_guardrail_assessment_map( deserializer: ShapeDeserializer, schema: Schema ) -> dict[str, GuardrailAssessment]: result: dict[str, GuardrailAssessment] = {} - value_schema = schema.members_by_index[1] + value_schema = schema.members["value"] def _read_value(k: str, d: ShapeDeserializer): if d.is_null(): @@ -12473,7 +13432,7 @@ def _read_value(k: str, d: ShapeDeserializer): def _serialize_model_outputs( serializer: ShapeSerializer, schema: Schema, value: list[str] ) -> None: - member_schema = schema.members_by_index[0] + member_schema = schema.members["member"] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_string(member_schema, e) @@ -12483,7 +13442,7 @@ def _deserialize_model_outputs( deserializer: ShapeDeserializer, schema: Schema ) -> list[str]: result: list[str] = [] - member_schema = schema.members_by_index[0] + member_schema = schema.members["member"] def _read_value(d: ShapeDeserializer): if d.is_null(): @@ -12502,7 +13461,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_by_index[1] + value_schema = schema.members["value"] for k, v in value.items(): m.entry( k, lambda vs: _serialize_guardrail_assessment_list(vs, value_schema, v) @@ -12513,7 +13472,7 @@ def _deserialize_guardrail_assessment_list_map( deserializer: ShapeDeserializer, schema: Schema ) -> dict[str, list[GuardrailAssessment]]: result: dict[str, list[GuardrailAssessment]] = {} - value_schema = schema.members_by_index[1] + value_schema = schema.members["value"] def _read_value(k: str, d: ShapeDeserializer): if d.is_null(): @@ -12549,25 +13508,35 @@ class GuardrailTraceAssessment: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_GUARDRAIL_TRACE_ASSESSMENT), self) + serializer.write_struct(_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, members[0], self.model_output) + _serialize_model_outputs( + serializer, + _SCHEMA_GUARDRAIL_TRACE_ASSESSMENT.members["modelOutput"], + self.model_output, + ) if self.input_assessment is not None: _serialize_guardrail_assessment_map( - serializer, members[1], self.input_assessment + serializer, + _SCHEMA_GUARDRAIL_TRACE_ASSESSMENT.members["inputAssessment"], + self.input_assessment, ) if self.output_assessments is not None: _serialize_guardrail_assessment_list_map( - serializer, members[2], self.output_assessments + serializer, + _SCHEMA_GUARDRAIL_TRACE_ASSESSMENT.members["outputAssessments"], + self.output_assessments, ) if self.action_reason is not None: - serializer.write_string(members[3], self.action_reason) + serializer.write_string( + _SCHEMA_GUARDRAIL_TRACE_ASSESSMENT.members["actionReason"], + self.action_reason, + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -12576,31 +13545,39 @@ 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(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: - kwargs["model_output"] = _deserialize_model_outputs(de, members[0]) + kwargs["model_output"] = _deserialize_model_outputs( + de, _SCHEMA_GUARDRAIL_TRACE_ASSESSMENT.members["modelOutput"] + ) case 1: kwargs["input_assessment"] = _deserialize_guardrail_assessment_map( - de, members[1] + de, + _SCHEMA_GUARDRAIL_TRACE_ASSESSMENT.members["inputAssessment"], ) case 2: kwargs["output_assessments"] = ( - _deserialize_guardrail_assessment_list_map(de, members[2]) + _deserialize_guardrail_assessment_list_map( + de, + _SCHEMA_GUARDRAIL_TRACE_ASSESSMENT.members[ + "outputAssessments" + ], + ) ) case 3: - kwargs["action_reason"] = de.read_string(members[3]) + kwargs["action_reason"] = de.read_string( + _SCHEMA_GUARDRAIL_TRACE_ASSESSMENT.members["actionReason"] + ) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct(_SCHEMA_GUARDRAIL_TRACE_ASSESSMENT, consumer=_consumer) return kwargs @@ -12612,12 +13589,14 @@ class PromptRouterTrace: """The ID of the invoked model.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_PROMPT_ROUTER_TRACE), self) + serializer.write_struct(_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(members[0], self.invoked_model_id) + serializer.write_string( + _SCHEMA_PROMPT_ROUTER_TRACE.members["invokedModelId"], + self.invoked_model_id, + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -12626,18 +13605,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(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: - kwargs["invoked_model_id"] = de.read_string(members[0]) + kwargs["invoked_model_id"] = de.read_string( + _SCHEMA_PROMPT_ROUTER_TRACE.members["invokedModelId"] + ) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct(_SCHEMA_PROMPT_ROUTER_TRACE, consumer=_consumer) return kwargs @@ -12655,15 +13634,18 @@ class ConverseTrace: """The request's prompt router.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_CONVERSE_TRACE), self) + serializer.write_struct(_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(members[0], self.guardrail) + serializer.write_struct( + _SCHEMA_CONVERSE_TRACE.members["guardrail"], self.guardrail + ) if self.prompt_router is not None: - serializer.write_struct(members[1], self.prompt_router) + serializer.write_struct( + _SCHEMA_CONVERSE_TRACE.members["promptRouter"], self.prompt_router + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -12672,11 +13654,9 @@ 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(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: kwargs["guardrail"] = GuardrailTraceAssessment.deserialize(de) @@ -12684,9 +13664,9 @@ def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: kwargs["prompt_router"] = PromptRouterTrace.deserialize(de) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct(_SCHEMA_CONVERSE_TRACE, consumer=_consumer) return kwargs @@ -12701,12 +13681,13 @@ class CacheDetail: """Number of tokens written to cache with this TTL (cache creation tokens)""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_CACHE_DETAIL), self) + serializer.write_struct(_SCHEMA_CACHE_DETAIL, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_CACHE_DETAIL).members_by_index - serializer.write_string(members[0], self.ttl) - serializer.write_integer(members[1], self.input_tokens) + serializer.write_string(_SCHEMA_CACHE_DETAIL.members["ttl"], self.ttl) + serializer.write_integer( + _SCHEMA_CACHE_DETAIL.members["inputTokens"], self.input_tokens + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -12715,21 +13696,23 @@ 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(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: - kwargs["ttl"] = CacheTTL(de.read_string(members[0])) + kwargs["ttl"] = CacheTTL( + de.read_string(_SCHEMA_CACHE_DETAIL.members["ttl"]) + ) case 1: - kwargs["input_tokens"] = de.read_integer(members[1]) + kwargs["input_tokens"] = de.read_integer( + _SCHEMA_CACHE_DETAIL.members["inputTokens"] + ) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct(_SCHEMA_CACHE_DETAIL, consumer=_consumer) if "ttl" not in kwargs: kwargs["ttl"] = CacheTTL._corrected("") if "input_tokens" not in kwargs: @@ -12740,7 +13723,7 @@ def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: def _serialize_cache_details_list( serializer: ShapeSerializer, schema: Schema, value: list[CacheDetail] ) -> None: - member_schema = schema.members_by_index[0] + member_schema = schema.members["member"] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_struct(member_schema, e) @@ -12788,21 +13771,36 @@ class TokenUsage: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_TOKEN_USAGE), self) + serializer.write_struct(_SCHEMA_TOKEN_USAGE, self) def serialize_members(self, serializer: ShapeSerializer): - 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) + 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 + ) if self.cache_read_input_tokens is not None: - serializer.write_integer(members[3], self.cache_read_input_tokens) + serializer.write_integer( + _SCHEMA_TOKEN_USAGE.members["cacheReadInputTokens"], + self.cache_read_input_tokens, + ) if self.cache_write_input_tokens is not None: - serializer.write_integer(members[4], self.cache_write_input_tokens) + serializer.write_integer( + _SCHEMA_TOKEN_USAGE.members["cacheWriteInputTokens"], + self.cache_write_input_tokens, + ) if self.cache_details is not None: - _serialize_cache_details_list(serializer, members[5], self.cache_details) + _serialize_cache_details_list( + serializer, + _SCHEMA_TOKEN_USAGE.members["cacheDetails"], + self.cache_details, + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -12811,35 +13809,43 @@ 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(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: - kwargs["input_tokens"] = de.read_integer(members[0]) + kwargs["input_tokens"] = de.read_integer( + _SCHEMA_TOKEN_USAGE.members["inputTokens"] + ) case 1: - kwargs["output_tokens"] = de.read_integer(members[1]) + kwargs["output_tokens"] = de.read_integer( + _SCHEMA_TOKEN_USAGE.members["outputTokens"] + ) case 2: - kwargs["total_tokens"] = de.read_integer(members[2]) + kwargs["total_tokens"] = de.read_integer( + _SCHEMA_TOKEN_USAGE.members["totalTokens"] + ) case 3: - kwargs["cache_read_input_tokens"] = de.read_integer(members[3]) + kwargs["cache_read_input_tokens"] = de.read_integer( + _SCHEMA_TOKEN_USAGE.members["cacheReadInputTokens"] + ) case 4: - kwargs["cache_write_input_tokens"] = de.read_integer(members[4]) + kwargs["cache_write_input_tokens"] = de.read_integer( + _SCHEMA_TOKEN_USAGE.members["cacheWriteInputTokens"] + ) case 5: kwargs["cache_details"] = _deserialize_cache_details_list( - de, members[5] + de, _SCHEMA_TOKEN_USAGE.members["cacheDetails"] ) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct(_SCHEMA_TOKEN_USAGE, consumer=_consumer) if "input_tokens" not in kwargs: kwargs["input_tokens"] = 0 if "output_tokens" not in kwargs: @@ -12899,25 +13905,45 @@ class ConverseOperationOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_CONVERSE_OPERATION_OUTPUT), self) + serializer.write_struct(_SCHEMA_CONVERSE_OPERATION_OUTPUT, self) def serialize_members(self, serializer: ShapeSerializer): - 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) + 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 + ) if self.additional_model_response_fields is not None: - serializer.write_document(members[4], self.additional_model_response_fields) + serializer.write_document( + _SCHEMA_CONVERSE_OPERATION_OUTPUT.members[ + "additionalModelResponseFields" + ], + self.additional_model_response_fields, + ) if self.trace is not None: - serializer.write_struct(members[5], self.trace) + serializer.write_struct( + _SCHEMA_CONVERSE_OPERATION_OUTPUT.members["trace"], self.trace + ) if self.performance_config is not None: - serializer.write_struct(members[6], self.performance_config) + serializer.write_struct( + _SCHEMA_CONVERSE_OPERATION_OUTPUT.members["performanceConfig"], + self.performance_config, + ) if self.service_tier is not None: - serializer.write_struct(members[7], self.service_tier) + serializer.write_struct( + _SCHEMA_CONVERSE_OPERATION_OUTPUT.members["serviceTier"], + self.service_tier, + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -12926,16 +13952,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_OPERATION_OUTPUT) - members = schema.members_by_index - def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: kwargs["output"] = _ConverseOutputDeserializer().deserialize(de) case 1: - kwargs["stop_reason"] = StopReason(de.read_string(members[1])) + kwargs["stop_reason"] = StopReason( + de.read_string( + _SCHEMA_CONVERSE_OPERATION_OUTPUT.members["stopReason"] + ) + ) case 2: kwargs["usage"] = TokenUsage.deserialize(de) @@ -12945,7 +13973,9 @@ def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: case 4: kwargs["additional_model_response_fields"] = de.read_document( - members[4] + _SCHEMA_CONVERSE_OPERATION_OUTPUT.members[ + "additionalModelResponseFields" + ] ) case 5: @@ -12960,9 +13990,9 @@ def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: kwargs["service_tier"] = ServiceTier.deserialize(de) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct(_SCHEMA_CONVERSE_OPERATION_OUTPUT, consumer=_consumer) if "output" not in kwargs: kwargs["output"] = ConverseOutputUnknown(tag="") if "stop_reason" not in kwargs: @@ -12987,18 +14017,25 @@ class ModelErrorException(ServiceError): """The resource name.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_MODEL_ERROR_EXCEPTION), self) + serializer.write_struct(_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(members[0], self.message) + serializer.write_string( + _SCHEMA_MODEL_ERROR_EXCEPTION.members["message"], self.message + ) if self.original_status_code is not None: - serializer.write_integer(members[1], self.original_status_code) + serializer.write_integer( + _SCHEMA_MODEL_ERROR_EXCEPTION.members["originalStatusCode"], + self.original_status_code, + ) if self.resource_name is not None: - serializer.write_string(members[2], self.resource_name) + serializer.write_string( + _SCHEMA_MODEL_ERROR_EXCEPTION.members["resourceName"], + self.resource_name, + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -13007,24 +14044,28 @@ 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(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: - kwargs["message"] = de.read_string(members[0]) + kwargs["message"] = de.read_string( + _SCHEMA_MODEL_ERROR_EXCEPTION.members["message"] + ) case 1: - kwargs["original_status_code"] = de.read_integer(members[1]) + kwargs["original_status_code"] = de.read_integer( + _SCHEMA_MODEL_ERROR_EXCEPTION.members["originalStatusCode"] + ) case 2: - kwargs["resource_name"] = de.read_string(members[2]) + kwargs["resource_name"] = de.read_string( + _SCHEMA_MODEL_ERROR_EXCEPTION.members["resourceName"] + ) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct(_SCHEMA_MODEL_ERROR_EXCEPTION, consumer=_consumer) return kwargs @@ -13042,12 +14083,13 @@ class ModelNotReadyException(ServiceError): is_retry_safe: bool | None = True def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_MODEL_NOT_READY_EXCEPTION), self) + serializer.write_struct(_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(members[0], self.message) + serializer.write_string( + _SCHEMA_MODEL_NOT_READY_EXCEPTION.members["message"], self.message + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -13056,18 +14098,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(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: - kwargs["message"] = de.read_string(members[0]) + kwargs["message"] = de.read_string( + _SCHEMA_MODEL_NOT_READY_EXCEPTION.members["message"] + ) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct(_SCHEMA_MODEL_NOT_READY_EXCEPTION, consumer=_consumer) return kwargs @@ -13081,12 +14123,13 @@ class ModelTimeoutException(ServiceError): fault: Literal["client", "server"] | None = "client" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_MODEL_TIMEOUT_EXCEPTION), self) + serializer.write_struct(_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(members[0], self.message) + serializer.write_string( + _SCHEMA_MODEL_TIMEOUT_EXCEPTION.members["message"], self.message + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -13095,25 +14138,27 @@ 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(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: - kwargs["message"] = de.read_string(members[0]) + kwargs["message"] = de.read_string( + _SCHEMA_MODEL_TIMEOUT_EXCEPTION.members["message"] + ) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct(_SCHEMA_MODEL_TIMEOUT_EXCEPTION, consumer=_consumer) return kwargs CONVERSE = APIOperation( input=ConverseInput, output=ConverseOperationOutput, - static_schema=_SCHEMA_CONVERSE, + schema=_SCHEMA_CONVERSE, + input_schema=_SCHEMA_CONVERSE_INPUT, + output_schema=_SCHEMA_CONVERSE_OPERATION_OUTPUT, error_registry=TypeRegistry( { ShapeID( @@ -13149,6 +14194,17 @@ def _consumer(member_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, + ], ) @@ -13183,14 +14239,24 @@ class GuardrailStreamConfiguration: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_GUARDRAIL_STREAM_CONFIGURATION), self) + serializer.write_struct(_SCHEMA_GUARDRAIL_STREAM_CONFIGURATION, self) def serialize_members(self, serializer: ShapeSerializer): - 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) + 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, + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -13199,29 +14265,45 @@ 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(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: - kwargs["guardrail_identifier"] = de.read_string(members[0]) + kwargs["guardrail_identifier"] = de.read_string( + _SCHEMA_GUARDRAIL_STREAM_CONFIGURATION.members[ + "guardrailIdentifier" + ] + ) case 1: - kwargs["guardrail_version"] = de.read_string(members[1]) + kwargs["guardrail_version"] = de.read_string( + _SCHEMA_GUARDRAIL_STREAM_CONFIGURATION.members[ + "guardrailVersion" + ] + ) case 2: - kwargs["trace"] = GuardrailTrace(de.read_string(members[2])) + kwargs["trace"] = GuardrailTrace( + de.read_string( + _SCHEMA_GUARDRAIL_STREAM_CONFIGURATION.members["trace"] + ) + ) case 3: kwargs["stream_processing_mode"] = GuardrailStreamProcessingMode( - de.read_string(members[3]) + de.read_string( + _SCHEMA_GUARDRAIL_STREAM_CONFIGURATION.members[ + "streamProcessingMode" + ] + ) ) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct( + _SCHEMA_GUARDRAIL_STREAM_CONFIGURATION, consumer=_consumer + ) return kwargs @@ -13357,52 +14439,88 @@ class ConverseStreamInput: """Output configuration for a model response.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_CONVERSE_STREAM_INPUT), self) + serializer.write_struct(_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(members[0], self.model_id) + serializer.write_string( + _SCHEMA_CONVERSE_STREAM_INPUT.members["modelId"], self.model_id + ) if self.messages is not None: - _serialize_messages(serializer, members[1], self.messages) + _serialize_messages( + serializer, + _SCHEMA_CONVERSE_STREAM_INPUT.members["messages"], + self.messages, + ) if self.system is not None: - _serialize_system_content_blocks(serializer, members[2], self.system) + _serialize_system_content_blocks( + serializer, _SCHEMA_CONVERSE_STREAM_INPUT.members["system"], self.system + ) if self.inference_config is not None: - serializer.write_struct(members[3], self.inference_config) + serializer.write_struct( + _SCHEMA_CONVERSE_STREAM_INPUT.members["inferenceConfig"], + self.inference_config, + ) if self.tool_config is not None: - serializer.write_struct(members[4], self.tool_config) + serializer.write_struct( + _SCHEMA_CONVERSE_STREAM_INPUT.members["toolConfig"], self.tool_config + ) if self.guardrail_config is not None: - serializer.write_struct(members[5], self.guardrail_config) + serializer.write_struct( + _SCHEMA_CONVERSE_STREAM_INPUT.members["guardrailConfig"], + self.guardrail_config, + ) if self.additional_model_request_fields is not None: - serializer.write_document(members[6], self.additional_model_request_fields) + serializer.write_document( + _SCHEMA_CONVERSE_STREAM_INPUT.members["additionalModelRequestFields"], + self.additional_model_request_fields, + ) if self.prompt_variables is not None: _serialize_prompt_variable_map( - serializer, members[7], self.prompt_variables + serializer, + _SCHEMA_CONVERSE_STREAM_INPUT.members["promptVariables"], + self.prompt_variables, ) if self.additional_model_response_field_paths is not None: _serialize_additional_model_response_field_paths( - serializer, members[8], self.additional_model_response_field_paths + serializer, + _SCHEMA_CONVERSE_STREAM_INPUT.members[ + "additionalModelResponseFieldPaths" + ], + self.additional_model_response_field_paths, ) if self.request_metadata is not None: - _serialize_request_metadata(serializer, members[9], self.request_metadata) + _serialize_request_metadata( + serializer, + _SCHEMA_CONVERSE_STREAM_INPUT.members["requestMetadata"], + self.request_metadata, + ) if self.performance_config is not None: - serializer.write_struct(members[10], self.performance_config) + serializer.write_struct( + _SCHEMA_CONVERSE_STREAM_INPUT.members["performanceConfig"], + self.performance_config, + ) if self.service_tier is not None: - serializer.write_struct(members[11], self.service_tier) + serializer.write_struct( + _SCHEMA_CONVERSE_STREAM_INPUT.members["serviceTier"], self.service_tier + ) if self.output_config is not None: - serializer.write_struct(members[12], self.output_config) + serializer.write_struct( + _SCHEMA_CONVERSE_STREAM_INPUT.members["outputConfig"], + self.output_config, + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -13411,20 +14529,22 @@ 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(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: - kwargs["model_id"] = de.read_string(members[0]) + kwargs["model_id"] = de.read_string( + _SCHEMA_CONVERSE_STREAM_INPUT.members["modelId"] + ) case 1: - kwargs["messages"] = _deserialize_messages(de, members[1]) + kwargs["messages"] = _deserialize_messages( + de, _SCHEMA_CONVERSE_STREAM_INPUT.members["messages"] + ) case 2: kwargs["system"] = _deserialize_system_content_blocks( - de, members[2] + de, _SCHEMA_CONVERSE_STREAM_INPUT.members["system"] ) case 3: @@ -13440,24 +14560,29 @@ def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: case 6: kwargs["additional_model_request_fields"] = de.read_document( - members[6] + _SCHEMA_CONVERSE_STREAM_INPUT.members[ + "additionalModelRequestFields" + ] ) case 7: kwargs["prompt_variables"] = _deserialize_prompt_variable_map( - de, members[7] + de, _SCHEMA_CONVERSE_STREAM_INPUT.members["promptVariables"] ) case 8: kwargs["additional_model_response_field_paths"] = ( _deserialize_additional_model_response_field_paths( - de, members[8] + de, + _SCHEMA_CONVERSE_STREAM_INPUT.members[ + "additionalModelResponseFieldPaths" + ], ) ) case 9: kwargs["request_metadata"] = _deserialize_request_metadata( - de, members[9] + de, _SCHEMA_CONVERSE_STREAM_INPUT.members["requestMetadata"] ) case 10: @@ -13472,9 +14597,9 @@ def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: kwargs["output_config"] = OutputConfig.deserialize(de) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct(_SCHEMA_CONVERSE_STREAM_INPUT, consumer=_consumer) return kwargs @@ -13492,12 +14617,13 @@ class CitationSourceContentDelta: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_CITATION_SOURCE_CONTENT_DELTA), self) + serializer.write_struct(_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(members[0], self.text) + serializer.write_string( + _SCHEMA_CITATION_SOURCE_CONTENT_DELTA.members["text"], self.text + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -13506,25 +14632,27 @@ 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(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: - kwargs["text"] = de.read_string(members[0]) + kwargs["text"] = de.read_string( + _SCHEMA_CITATION_SOURCE_CONTENT_DELTA.members["text"] + ) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct( + _SCHEMA_CITATION_SOURCE_CONTENT_DELTA, consumer=_consumer + ) return kwargs def _serialize_citation_source_content_list_delta( serializer: ShapeSerializer, schema: Schema, value: list[CitationSourceContentDelta] ) -> None: - member_schema = schema.members_by_index[0] + member_schema = schema.members["member"] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_struct(member_schema, e) @@ -13578,23 +14706,30 @@ class CitationsDelta: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_CITATIONS_DELTA), self) + serializer.write_struct(_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(members[0], self.title) + serializer.write_string( + _SCHEMA_CITATIONS_DELTA.members["title"], self.title + ) if self.source is not None: - serializer.write_string(members[1], self.source) + serializer.write_string( + _SCHEMA_CITATIONS_DELTA.members["source"], self.source + ) if self.source_content is not None: _serialize_citation_source_content_list_delta( - serializer, members[2], self.source_content + serializer, + _SCHEMA_CITATIONS_DELTA.members["sourceContent"], + self.source_content, ) if self.location is not None: - serializer.write_struct(members[3], self.location) + serializer.write_struct( + _SCHEMA_CITATIONS_DELTA.members["location"], self.location + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -13603,29 +14738,33 @@ 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(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: - kwargs["title"] = de.read_string(members[0]) + kwargs["title"] = de.read_string( + _SCHEMA_CITATIONS_DELTA.members["title"] + ) case 1: - kwargs["source"] = de.read_string(members[1]) + kwargs["source"] = de.read_string( + _SCHEMA_CITATIONS_DELTA.members["source"] + ) case 2: kwargs["source_content"] = ( - _deserialize_citation_source_content_list_delta(de, members[2]) + _deserialize_citation_source_content_list_delta( + de, _SCHEMA_CITATIONS_DELTA.members["sourceContent"] + ) ) case 3: kwargs["location"] = _CitationLocationDeserializer().deserialize(de) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct(_SCHEMA_CITATIONS_DELTA, consumer=_consumer) return kwargs @@ -13643,15 +14782,18 @@ class ImageBlockDelta: """Error information if this image delta could not be processed.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_IMAGE_BLOCK_DELTA), self) + serializer.write_struct(_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(members[0], self.source) + serializer.write_struct( + _SCHEMA_IMAGE_BLOCK_DELTA.members["source"], self.source + ) if self.error is not None: - serializer.write_struct(members[1], self.error) + serializer.write_struct( + _SCHEMA_IMAGE_BLOCK_DELTA.members["error"], self.error + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -13660,11 +14802,9 @@ 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(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: kwargs["source"] = _ImageSourceDeserializer().deserialize(de) @@ -13672,9 +14812,9 @@ def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: kwargs["error"] = ErrorBlock.deserialize(de) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct(_SCHEMA_IMAGE_BLOCK_DELTA, consumer=_consumer) return kwargs @@ -13685,16 +14825,20 @@ class ReasoningContentBlockDeltaText: value: str def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_REASONING_CONTENT_BLOCK_DELTA), self) + serializer.write_struct(_SCHEMA_REASONING_CONTENT_BLOCK_DELTA, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_REASONING_CONTENT_BLOCK_DELTA).members_by_index - serializer.write_string(members[0], self.value) + serializer.write_string( + _SCHEMA_REASONING_CONTENT_BLOCK_DELTA.members["text"], self.value + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: - members = hydrate(_SCHEMA_REASONING_CONTENT_BLOCK_DELTA).members_by_index - return cls(value=deserializer.read_string(members[0])) + return cls( + value=deserializer.read_string( + _SCHEMA_REASONING_CONTENT_BLOCK_DELTA.members["text"] + ) + ) @dataclass @@ -13708,16 +14852,20 @@ class ReasoningContentBlockDeltaRedactedContent: value: bytes def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_REASONING_CONTENT_BLOCK_DELTA), self) + serializer.write_struct(_SCHEMA_REASONING_CONTENT_BLOCK_DELTA, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_REASONING_CONTENT_BLOCK_DELTA).members_by_index - serializer.write_blob(members[1], self.value) + serializer.write_blob( + _SCHEMA_REASONING_CONTENT_BLOCK_DELTA.members["redactedContent"], self.value + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: - members = hydrate(_SCHEMA_REASONING_CONTENT_BLOCK_DELTA).members_by_index - return cls(value=deserializer.read_blob(members[1])) + return cls( + value=deserializer.read_blob( + _SCHEMA_REASONING_CONTENT_BLOCK_DELTA.members["redactedContent"] + ) + ) @dataclass @@ -13731,16 +14879,20 @@ class ReasoningContentBlockDeltaSignature: value: str def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_REASONING_CONTENT_BLOCK_DELTA), self) + serializer.write_struct(_SCHEMA_REASONING_CONTENT_BLOCK_DELTA, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_REASONING_CONTENT_BLOCK_DELTA).members_by_index - serializer.write_string(members[2], self.value) + serializer.write_string( + _SCHEMA_REASONING_CONTENT_BLOCK_DELTA.members["signature"], self.value + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: - members = hydrate(_SCHEMA_REASONING_CONTENT_BLOCK_DELTA).members_by_index - return cls(value=deserializer.read_string(members[2])) + return cls( + value=deserializer.read_string( + _SCHEMA_REASONING_CONTENT_BLOCK_DELTA.members["signature"] + ) + ) @dataclass @@ -13788,9 +14940,7 @@ def deserialize( self, deserializer: ShapeDeserializer ) -> ReasoningContentBlockDelta: self._result = None - deserializer.read_struct( - hydrate(_SCHEMA_REASONING_CONTENT_BLOCK_DELTA), self._consumer - ) + deserializer.read_struct(_SCHEMA_REASONING_CONTENT_BLOCK_DELTA, self._consumer) if self._result is None: raise SerializationError( @@ -13832,16 +14982,20 @@ class ToolResultBlockDeltaText: value: str def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_TOOL_RESULT_BLOCK_DELTA), self) + serializer.write_struct(_SCHEMA_TOOL_RESULT_BLOCK_DELTA, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_TOOL_RESULT_BLOCK_DELTA).members_by_index - serializer.write_string(members[0], self.value) + serializer.write_string( + _SCHEMA_TOOL_RESULT_BLOCK_DELTA.members["text"], self.value + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: - members = hydrate(_SCHEMA_TOOL_RESULT_BLOCK_DELTA).members_by_index - return cls(value=deserializer.read_string(members[0])) + return cls( + value=deserializer.read_string( + _SCHEMA_TOOL_RESULT_BLOCK_DELTA.members["text"] + ) + ) @dataclass @@ -13854,16 +15008,20 @@ class ToolResultBlockDeltaJson: value: Document def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_TOOL_RESULT_BLOCK_DELTA), self) + serializer.write_struct(_SCHEMA_TOOL_RESULT_BLOCK_DELTA, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_TOOL_RESULT_BLOCK_DELTA).members_by_index - serializer.write_document(members[1], self.value) + serializer.write_document( + _SCHEMA_TOOL_RESULT_BLOCK_DELTA.members["json"], self.value + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: - members = hydrate(_SCHEMA_TOOL_RESULT_BLOCK_DELTA).members_by_index - return cls(value=deserializer.read_document(members[1])) + return cls( + value=deserializer.read_document( + _SCHEMA_TOOL_RESULT_BLOCK_DELTA.members["json"] + ) + ) @dataclass @@ -13905,9 +15063,7 @@ class _ToolResultBlockDeltaDeserializer: def deserialize(self, deserializer: ShapeDeserializer) -> ToolResultBlockDelta: self._result = None - deserializer.read_struct( - hydrate(_SCHEMA_TOOL_RESULT_BLOCK_DELTA), self._consumer - ) + deserializer.read_struct(_SCHEMA_TOOL_RESULT_BLOCK_DELTA, self._consumer) if self._result is None: raise SerializationError( @@ -13940,7 +15096,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_by_index[0] + member_schema = schema.members["member"] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_struct(member_schema, e) @@ -13970,11 +15126,12 @@ class ToolUseBlockDelta: """The input for a requested tool.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_TOOL_USE_BLOCK_DELTA), self) + serializer.write_struct(_SCHEMA_TOOL_USE_BLOCK_DELTA, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_TOOL_USE_BLOCK_DELTA).members_by_index - serializer.write_string(members[0], self.input) + serializer.write_string( + _SCHEMA_TOOL_USE_BLOCK_DELTA.members["input"], self.input + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -13983,18 +15140,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(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: - kwargs["input"] = de.read_string(members[0]) + kwargs["input"] = de.read_string( + _SCHEMA_TOOL_USE_BLOCK_DELTA.members["input"] + ) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct(_SCHEMA_TOOL_USE_BLOCK_DELTA, consumer=_consumer) if "input" not in kwargs: kwargs["input"] = "" return kwargs @@ -14007,16 +15164,16 @@ class ContentBlockDeltaText: value: str def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_CONTENT_BLOCK_DELTA), self) + serializer.write_struct(_SCHEMA_CONTENT_BLOCK_DELTA, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_CONTENT_BLOCK_DELTA).members_by_index - serializer.write_string(members[0], self.value) + serializer.write_string(_SCHEMA_CONTENT_BLOCK_DELTA.members["text"], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: - members = hydrate(_SCHEMA_CONTENT_BLOCK_DELTA).members_by_index - return cls(value=deserializer.read_string(members[0])) + return cls( + value=deserializer.read_string(_SCHEMA_CONTENT_BLOCK_DELTA.members["text"]) + ) @dataclass @@ -14026,11 +15183,12 @@ class ContentBlockDeltaToolUse: value: ToolUseBlockDelta def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_CONTENT_BLOCK_DELTA), self) + serializer.write_struct(_SCHEMA_CONTENT_BLOCK_DELTA, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_CONTENT_BLOCK_DELTA).members_by_index - serializer.write_struct(members[1], self.value) + serializer.write_struct( + _SCHEMA_CONTENT_BLOCK_DELTA.members["toolUse"], self.value + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -14044,17 +15202,19 @@ class ContentBlockDeltaToolResult: value: list[ToolResultBlockDelta] def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_CONTENT_BLOCK_DELTA), self) + serializer.write_struct(_SCHEMA_CONTENT_BLOCK_DELTA, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_CONTENT_BLOCK_DELTA).members_by_index - _serialize_tool_result_blocks_delta(serializer, members[2], self.value) + _serialize_tool_result_blocks_delta( + serializer, _SCHEMA_CONTENT_BLOCK_DELTA.members["toolResult"], 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, members[2]) + value=_deserialize_tool_result_blocks_delta( + deserializer, _SCHEMA_CONTENT_BLOCK_DELTA.members["toolResult"] + ) ) @@ -14069,11 +15229,12 @@ class ContentBlockDeltaReasoningContent: value: ReasoningContentBlockDelta def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_CONTENT_BLOCK_DELTA), self) + serializer.write_struct(_SCHEMA_CONTENT_BLOCK_DELTA, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_CONTENT_BLOCK_DELTA).members_by_index - serializer.write_struct(members[3], self.value) + serializer.write_struct( + _SCHEMA_CONTENT_BLOCK_DELTA.members["reasoningContent"], self.value + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -14092,11 +15253,12 @@ class ContentBlockDeltaCitation: value: CitationsDelta def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_CONTENT_BLOCK_DELTA), self) + serializer.write_struct(_SCHEMA_CONTENT_BLOCK_DELTA, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_CONTENT_BLOCK_DELTA).members_by_index - serializer.write_struct(members[4], self.value) + serializer.write_struct( + _SCHEMA_CONTENT_BLOCK_DELTA.members["citation"], self.value + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -14110,11 +15272,12 @@ class ContentBlockDeltaImage: value: ImageBlockDelta def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_CONTENT_BLOCK_DELTA), self) + serializer.write_struct(_SCHEMA_CONTENT_BLOCK_DELTA, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_CONTENT_BLOCK_DELTA).members_by_index - serializer.write_struct(members[5], self.value) + serializer.write_struct( + _SCHEMA_CONTENT_BLOCK_DELTA.members["image"], self.value + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -14162,7 +15325,7 @@ class _ContentBlockDeltaDeserializer: def deserialize(self, deserializer: ShapeDeserializer) -> ContentBlockDelta: self._result = None - deserializer.read_struct(hydrate(_SCHEMA_CONTENT_BLOCK_DELTA), self._consumer) + deserializer.read_struct(_SCHEMA_CONTENT_BLOCK_DELTA, self._consumer) if self._result is None: raise SerializationError( @@ -14215,12 +15378,16 @@ class ContentBlockDeltaEvent: """The block index for a content block delta event.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_CONTENT_BLOCK_DELTA_EVENT), self) + serializer.write_struct(_SCHEMA_CONTENT_BLOCK_DELTA_EVENT, self) def serialize_members(self, serializer: ShapeSerializer): - 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) + 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, + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -14229,21 +15396,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(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: kwargs["delta"] = _ContentBlockDeltaDeserializer().deserialize(de) case 1: - kwargs["content_block_index"] = de.read_integer(members[1]) + kwargs["content_block_index"] = de.read_integer( + _SCHEMA_CONTENT_BLOCK_DELTA_EVENT.members["contentBlockIndex"] + ) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct(_SCHEMA_CONTENT_BLOCK_DELTA_EVENT, consumer=_consumer) if "delta" not in kwargs: kwargs["delta"] = ContentBlockDeltaUnknown(tag="") if "content_block_index" not in kwargs: @@ -14265,11 +15432,12 @@ class ImageBlockStart: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_IMAGE_BLOCK_START), self) + serializer.write_struct(_SCHEMA_IMAGE_BLOCK_START, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_IMAGE_BLOCK_START).members_by_index - serializer.write_string(members[0], self.format) + serializer.write_string( + _SCHEMA_IMAGE_BLOCK_START.members["format"], self.format + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -14278,18 +15446,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(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: - kwargs["format"] = ImageFormat(de.read_string(members[0])) + kwargs["format"] = ImageFormat( + de.read_string(_SCHEMA_IMAGE_BLOCK_START.members["format"]) + ) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct(_SCHEMA_IMAGE_BLOCK_START, consumer=_consumer) if "format" not in kwargs: kwargs["format"] = ImageFormat._corrected("") return kwargs @@ -14314,16 +15482,21 @@ class ToolResultBlockStart: """The status of the tool result block.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_TOOL_RESULT_BLOCK_START), self) + serializer.write_struct(_SCHEMA_TOOL_RESULT_BLOCK_START, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_TOOL_RESULT_BLOCK_START).members_by_index - serializer.write_string(members[0], self.tool_use_id) + serializer.write_string( + _SCHEMA_TOOL_RESULT_BLOCK_START.members["toolUseId"], self.tool_use_id + ) if self.type is not None: - serializer.write_string(members[1], self.type) + serializer.write_string( + _SCHEMA_TOOL_RESULT_BLOCK_START.members["type"], self.type + ) if self.status is not None: - serializer.write_string(members[2], self.status) + serializer.write_string( + _SCHEMA_TOOL_RESULT_BLOCK_START.members["status"], self.status + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -14332,24 +15505,30 @@ 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(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: - kwargs["tool_use_id"] = de.read_string(members[0]) + kwargs["tool_use_id"] = de.read_string( + _SCHEMA_TOOL_RESULT_BLOCK_START.members["toolUseId"] + ) case 1: - kwargs["type"] = de.read_string(members[1]) + kwargs["type"] = de.read_string( + _SCHEMA_TOOL_RESULT_BLOCK_START.members["type"] + ) case 2: - kwargs["status"] = ToolResultStatus(de.read_string(members[2])) + kwargs["status"] = ToolResultStatus( + de.read_string( + _SCHEMA_TOOL_RESULT_BLOCK_START.members["status"] + ) + ) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct(_SCHEMA_TOOL_RESULT_BLOCK_START, consumer=_consumer) if "tool_use_id" not in kwargs: kwargs["tool_use_id"] = "" return kwargs @@ -14374,14 +15553,17 @@ class ToolUseBlockStart: """The type for the tool request.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_TOOL_USE_BLOCK_START), self) + serializer.write_struct(_SCHEMA_TOOL_USE_BLOCK_START, self) def serialize_members(self, serializer: ShapeSerializer): - 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) + 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) if self.type is not None: - serializer.write_string(members[2], self.type) + serializer.write_string( + _SCHEMA_TOOL_USE_BLOCK_START.members["type"], self.type + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -14390,24 +15572,28 @@ 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(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: - kwargs["tool_use_id"] = de.read_string(members[0]) + kwargs["tool_use_id"] = de.read_string( + _SCHEMA_TOOL_USE_BLOCK_START.members["toolUseId"] + ) case 1: - kwargs["name"] = de.read_string(members[1]) + kwargs["name"] = de.read_string( + _SCHEMA_TOOL_USE_BLOCK_START.members["name"] + ) case 2: - kwargs["type"] = ToolUseType(de.read_string(members[2])) + kwargs["type"] = ToolUseType( + de.read_string(_SCHEMA_TOOL_USE_BLOCK_START.members["type"]) + ) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct(_SCHEMA_TOOL_USE_BLOCK_START, consumer=_consumer) if "tool_use_id" not in kwargs: kwargs["tool_use_id"] = "" if "name" not in kwargs: @@ -14422,11 +15608,12 @@ class ContentBlockStartToolUse: value: ToolUseBlockStart def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_CONTENT_BLOCK_START), self) + serializer.write_struct(_SCHEMA_CONTENT_BLOCK_START, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_CONTENT_BLOCK_START).members_by_index - serializer.write_struct(members[0], self.value) + serializer.write_struct( + _SCHEMA_CONTENT_BLOCK_START.members["toolUse"], self.value + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -14440,11 +15627,12 @@ class ContentBlockStartToolResult: value: ToolResultBlockStart def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_CONTENT_BLOCK_START), self) + serializer.write_struct(_SCHEMA_CONTENT_BLOCK_START, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_CONTENT_BLOCK_START).members_by_index - serializer.write_struct(members[1], self.value) + serializer.write_struct( + _SCHEMA_CONTENT_BLOCK_START.members["toolResult"], self.value + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -14458,11 +15646,12 @@ class ContentBlockStartImage: value: ImageBlockStart def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_CONTENT_BLOCK_START), self) + serializer.write_struct(_SCHEMA_CONTENT_BLOCK_START, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_CONTENT_BLOCK_START).members_by_index - serializer.write_struct(members[2], self.value) + serializer.write_struct( + _SCHEMA_CONTENT_BLOCK_START.members["image"], self.value + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -14507,7 +15696,7 @@ class _ContentBlockStartDeserializer: def deserialize(self, deserializer: ShapeDeserializer) -> ContentBlockStart: self._result = None - deserializer.read_struct(hydrate(_SCHEMA_CONTENT_BLOCK_START), self._consumer) + deserializer.read_struct(_SCHEMA_CONTENT_BLOCK_START, self._consumer) if self._result is None: raise SerializationError( @@ -14551,12 +15740,16 @@ class ContentBlockStartEvent: """The index for a content block start event.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_CONTENT_BLOCK_START_EVENT), self) + serializer.write_struct(_SCHEMA_CONTENT_BLOCK_START_EVENT, self) def serialize_members(self, serializer: ShapeSerializer): - 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) + 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, + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -14565,21 +15758,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(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: kwargs["start"] = _ContentBlockStartDeserializer().deserialize(de) case 1: - kwargs["content_block_index"] = de.read_integer(members[1]) + kwargs["content_block_index"] = de.read_integer( + _SCHEMA_CONTENT_BLOCK_START_EVENT.members["contentBlockIndex"] + ) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct(_SCHEMA_CONTENT_BLOCK_START_EVENT, consumer=_consumer) if "start" not in kwargs: kwargs["start"] = ContentBlockStartUnknown(tag="") if "content_block_index" not in kwargs: @@ -14595,11 +15788,13 @@ class ContentBlockStopEvent: """The index for a content block.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_CONTENT_BLOCK_STOP_EVENT), self) + serializer.write_struct(_SCHEMA_CONTENT_BLOCK_STOP_EVENT, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_CONTENT_BLOCK_STOP_EVENT).members_by_index - serializer.write_integer(members[0], self.content_block_index) + serializer.write_integer( + _SCHEMA_CONTENT_BLOCK_STOP_EVENT.members["contentBlockIndex"], + self.content_block_index, + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -14608,18 +15803,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(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: - kwargs["content_block_index"] = de.read_integer(members[0]) + kwargs["content_block_index"] = de.read_integer( + _SCHEMA_CONTENT_BLOCK_STOP_EVENT.members["contentBlockIndex"] + ) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct(_SCHEMA_CONTENT_BLOCK_STOP_EVENT, consumer=_consumer) if "content_block_index" not in kwargs: kwargs["content_block_index"] = 0 return kwargs @@ -14633,11 +15828,10 @@ class MessageStartEvent: """The role for the message.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_MESSAGE_START_EVENT), self) + serializer.write_struct(_SCHEMA_MESSAGE_START_EVENT, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_MESSAGE_START_EVENT).members_by_index - serializer.write_string(members[0], self.role) + serializer.write_string(_SCHEMA_MESSAGE_START_EVENT.members["role"], self.role) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -14646,18 +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_MESSAGE_START_EVENT) - members = schema.members_by_index - def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: - kwargs["role"] = ConversationRole(de.read_string(members[0])) + kwargs["role"] = ConversationRole( + de.read_string(_SCHEMA_MESSAGE_START_EVENT.members["role"]) + ) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct(_SCHEMA_MESSAGE_START_EVENT, consumer=_consumer) if "role" not in kwargs: kwargs["role"] = ConversationRole._corrected("") return kwargs @@ -14674,13 +15868,17 @@ class MessageStopEvent: """The additional model response fields.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_MESSAGE_STOP_EVENT), self) + serializer.write_struct(_SCHEMA_MESSAGE_STOP_EVENT, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_MESSAGE_STOP_EVENT).members_by_index - serializer.write_string(members[0], self.stop_reason) + serializer.write_string( + _SCHEMA_MESSAGE_STOP_EVENT.members["stopReason"], self.stop_reason + ) if self.additional_model_response_fields is not None: - serializer.write_document(members[1], self.additional_model_response_fields) + serializer.write_document( + _SCHEMA_MESSAGE_STOP_EVENT.members["additionalModelResponseFields"], + self.additional_model_response_fields, + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -14689,23 +15887,25 @@ 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(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: - kwargs["stop_reason"] = StopReason(de.read_string(members[0])) + kwargs["stop_reason"] = StopReason( + de.read_string(_SCHEMA_MESSAGE_STOP_EVENT.members["stopReason"]) + ) case 1: kwargs["additional_model_response_fields"] = de.read_document( - members[1] + _SCHEMA_MESSAGE_STOP_EVENT.members[ + "additionalModelResponseFields" + ] ) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct(_SCHEMA_MESSAGE_STOP_EVENT, consumer=_consumer) if "stop_reason" not in kwargs: kwargs["stop_reason"] = StopReason._corrected("") return kwargs @@ -14719,11 +15919,12 @@ class ConverseStreamMetrics: """The latency for the streaming request, in milliseconds.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_CONVERSE_STREAM_METRICS), self) + serializer.write_struct(_SCHEMA_CONVERSE_STREAM_METRICS, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_CONVERSE_STREAM_METRICS).members_by_index - serializer.write_long(members[0], self.latency_ms) + serializer.write_long( + _SCHEMA_CONVERSE_STREAM_METRICS.members["latencyMs"], self.latency_ms + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -14732,18 +15933,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(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: - kwargs["latency_ms"] = de.read_long(members[0]) + kwargs["latency_ms"] = de.read_long( + _SCHEMA_CONVERSE_STREAM_METRICS.members["latencyMs"] + ) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct(_SCHEMA_CONVERSE_STREAM_METRICS, consumer=_consumer) if "latency_ms" not in kwargs: kwargs["latency_ms"] = 0 return kwargs @@ -14767,15 +15968,19 @@ class ConverseStreamTrace: """The request's prompt router.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_CONVERSE_STREAM_TRACE), self) + serializer.write_struct(_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(members[0], self.guardrail) + serializer.write_struct( + _SCHEMA_CONVERSE_STREAM_TRACE.members["guardrail"], self.guardrail + ) if self.prompt_router is not None: - serializer.write_struct(members[1], self.prompt_router) + serializer.write_struct( + _SCHEMA_CONVERSE_STREAM_TRACE.members["promptRouter"], + self.prompt_router, + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -14784,11 +15989,9 @@ 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(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: kwargs["guardrail"] = GuardrailTraceAssessment.deserialize(de) @@ -14796,9 +15999,9 @@ def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: kwargs["prompt_router"] = PromptRouterTrace.deserialize(de) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct(_SCHEMA_CONVERSE_STREAM_TRACE, consumer=_consumer) return kwargs @@ -14832,20 +16035,31 @@ class ConverseStreamMetadataEvent: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_CONVERSE_STREAM_METADATA_EVENT), self) + serializer.write_struct(_SCHEMA_CONVERSE_STREAM_METADATA_EVENT, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_CONVERSE_STREAM_METADATA_EVENT).members_by_index - serializer.write_struct(members[0], self.usage) - serializer.write_struct(members[1], self.metrics) + serializer.write_struct( + _SCHEMA_CONVERSE_STREAM_METADATA_EVENT.members["usage"], self.usage + ) + serializer.write_struct( + _SCHEMA_CONVERSE_STREAM_METADATA_EVENT.members["metrics"], self.metrics + ) if self.trace is not None: - serializer.write_struct(members[2], self.trace) + serializer.write_struct( + _SCHEMA_CONVERSE_STREAM_METADATA_EVENT.members["trace"], self.trace + ) if self.performance_config is not None: - serializer.write_struct(members[3], self.performance_config) + serializer.write_struct( + _SCHEMA_CONVERSE_STREAM_METADATA_EVENT.members["performanceConfig"], + self.performance_config, + ) if self.service_tier is not None: - serializer.write_struct(members[4], self.service_tier) + serializer.write_struct( + _SCHEMA_CONVERSE_STREAM_METADATA_EVENT.members["serviceTier"], + self.service_tier, + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -14854,11 +16068,9 @@ 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(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: kwargs["usage"] = TokenUsage.deserialize(de) @@ -14877,9 +16089,11 @@ def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: kwargs["service_tier"] = ServiceTier.deserialize(de) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct( + _SCHEMA_CONVERSE_STREAM_METADATA_EVENT, consumer=_consumer + ) if "usage" not in kwargs: kwargs["usage"] = TokenUsage._smithy_default() if "metrics" not in kwargs: @@ -14900,18 +16114,25 @@ class ModelStreamErrorException(ServiceError): """The original message.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_MODEL_STREAM_ERROR_EXCEPTION), self) + serializer.write_struct(_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(members[0], self.message) + serializer.write_string( + _SCHEMA_MODEL_STREAM_ERROR_EXCEPTION.members["message"], self.message + ) if self.original_status_code is not None: - serializer.write_integer(members[1], self.original_status_code) + serializer.write_integer( + _SCHEMA_MODEL_STREAM_ERROR_EXCEPTION.members["originalStatusCode"], + self.original_status_code, + ) if self.original_message is not None: - serializer.write_string(members[2], self.original_message) + serializer.write_string( + _SCHEMA_MODEL_STREAM_ERROR_EXCEPTION.members["originalMessage"], + self.original_message, + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -14920,24 +16141,32 @@ 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(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: - kwargs["message"] = de.read_string(members[0]) + kwargs["message"] = de.read_string( + _SCHEMA_MODEL_STREAM_ERROR_EXCEPTION.members["message"] + ) case 1: - kwargs["original_status_code"] = de.read_integer(members[1]) + kwargs["original_status_code"] = de.read_integer( + _SCHEMA_MODEL_STREAM_ERROR_EXCEPTION.members[ + "originalStatusCode" + ] + ) case 2: - kwargs["original_message"] = de.read_string(members[2]) + kwargs["original_message"] = de.read_string( + _SCHEMA_MODEL_STREAM_ERROR_EXCEPTION.members["originalMessage"] + ) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct( + _SCHEMA_MODEL_STREAM_ERROR_EXCEPTION, consumer=_consumer + ) return kwargs @@ -14948,11 +16177,12 @@ class ConverseStreamOutputMessageStart: value: MessageStartEvent def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_CONVERSE_STREAM_OUTPUT), self) + serializer.write_struct(_SCHEMA_CONVERSE_STREAM_OUTPUT, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_CONVERSE_STREAM_OUTPUT).members_by_index - serializer.write_struct(members[0], self.value) + serializer.write_struct( + _SCHEMA_CONVERSE_STREAM_OUTPUT.members["messageStart"], self.value + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -14966,11 +16196,12 @@ class ConverseStreamOutputContentBlockStart: value: ContentBlockStartEvent def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_CONVERSE_STREAM_OUTPUT), self) + serializer.write_struct(_SCHEMA_CONVERSE_STREAM_OUTPUT, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_CONVERSE_STREAM_OUTPUT).members_by_index - serializer.write_struct(members[1], self.value) + serializer.write_struct( + _SCHEMA_CONVERSE_STREAM_OUTPUT.members["contentBlockStart"], self.value + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -14984,11 +16215,12 @@ class ConverseStreamOutputContentBlockDelta: value: ContentBlockDeltaEvent def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_CONVERSE_STREAM_OUTPUT), self) + serializer.write_struct(_SCHEMA_CONVERSE_STREAM_OUTPUT, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_CONVERSE_STREAM_OUTPUT).members_by_index - serializer.write_struct(members[2], self.value) + serializer.write_struct( + _SCHEMA_CONVERSE_STREAM_OUTPUT.members["contentBlockDelta"], self.value + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -15002,11 +16234,12 @@ class ConverseStreamOutputContentBlockStop: value: ContentBlockStopEvent def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_CONVERSE_STREAM_OUTPUT), self) + serializer.write_struct(_SCHEMA_CONVERSE_STREAM_OUTPUT, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_CONVERSE_STREAM_OUTPUT).members_by_index - serializer.write_struct(members[3], self.value) + serializer.write_struct( + _SCHEMA_CONVERSE_STREAM_OUTPUT.members["contentBlockStop"], self.value + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -15020,11 +16253,12 @@ class ConverseStreamOutputMessageStop: value: MessageStopEvent def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_CONVERSE_STREAM_OUTPUT), self) + serializer.write_struct(_SCHEMA_CONVERSE_STREAM_OUTPUT, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_CONVERSE_STREAM_OUTPUT).members_by_index - serializer.write_struct(members[4], self.value) + serializer.write_struct( + _SCHEMA_CONVERSE_STREAM_OUTPUT.members["messageStop"], self.value + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -15038,11 +16272,12 @@ class ConverseStreamOutputMetadata: value: ConverseStreamMetadataEvent def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_CONVERSE_STREAM_OUTPUT), self) + serializer.write_struct(_SCHEMA_CONVERSE_STREAM_OUTPUT, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_CONVERSE_STREAM_OUTPUT).members_by_index - serializer.write_struct(members[5], self.value) + serializer.write_struct( + _SCHEMA_CONVERSE_STREAM_OUTPUT.members["metadata"], self.value + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -15056,11 +16291,13 @@ class ConverseStreamOutputInternalServerException: value: InternalServerException def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_CONVERSE_STREAM_OUTPUT), self) + serializer.write_struct(_SCHEMA_CONVERSE_STREAM_OUTPUT, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_CONVERSE_STREAM_OUTPUT).members_by_index - serializer.write_struct(members[6], self.value) + serializer.write_struct( + _SCHEMA_CONVERSE_STREAM_OUTPUT.members["internalServerException"], + self.value, + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -15074,11 +16311,13 @@ class ConverseStreamOutputModelStreamErrorException: value: ModelStreamErrorException def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_CONVERSE_STREAM_OUTPUT), self) + serializer.write_struct(_SCHEMA_CONVERSE_STREAM_OUTPUT, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_CONVERSE_STREAM_OUTPUT).members_by_index - serializer.write_struct(members[7], self.value) + serializer.write_struct( + _SCHEMA_CONVERSE_STREAM_OUTPUT.members["modelStreamErrorException"], + self.value, + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -15097,11 +16336,12 @@ class ConverseStreamOutputValidationException: value: ValidationException def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_CONVERSE_STREAM_OUTPUT), self) + serializer.write_struct(_SCHEMA_CONVERSE_STREAM_OUTPUT, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_CONVERSE_STREAM_OUTPUT).members_by_index - serializer.write_struct(members[8], self.value) + serializer.write_struct( + _SCHEMA_CONVERSE_STREAM_OUTPUT.members["validationException"], self.value + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -15120,11 +16360,12 @@ class ConverseStreamOutputThrottlingException: value: ThrottlingException def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_CONVERSE_STREAM_OUTPUT), self) + serializer.write_struct(_SCHEMA_CONVERSE_STREAM_OUTPUT, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_CONVERSE_STREAM_OUTPUT).members_by_index - serializer.write_struct(members[9], self.value) + serializer.write_struct( + _SCHEMA_CONVERSE_STREAM_OUTPUT.members["throttlingException"], self.value + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -15143,11 +16384,13 @@ class ConverseStreamOutputServiceUnavailableException: value: ServiceUnavailableException def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_CONVERSE_STREAM_OUTPUT), self) + serializer.write_struct(_SCHEMA_CONVERSE_STREAM_OUTPUT, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_CONVERSE_STREAM_OUTPUT).members_by_index - serializer.write_struct(members[10], self.value) + serializer.write_struct( + _SCHEMA_CONVERSE_STREAM_OUTPUT.members["serviceUnavailableException"], + self.value, + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -15200,9 +16443,7 @@ class _ConverseStreamOutputDeserializer: def deserialize(self, deserializer: ShapeDeserializer) -> ConverseStreamOutput: self._result = None - deserializer.read_struct( - hydrate(_SCHEMA_CONVERSE_STREAM_OUTPUT), self._consumer - ) + deserializer.read_struct(_SCHEMA_CONVERSE_STREAM_OUTPUT, self._consumer) if self._result is None: raise SerializationError( @@ -15284,7 +16525,7 @@ class ConverseStreamOperationOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_CONVERSE_STREAM_OPERATION_OUTPUT), self) + serializer.write_struct(_SCHEMA_CONVERSE_STREAM_OPERATION_OUTPUT, self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -15296,21 +16537,24 @@ 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(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct( + _SCHEMA_CONVERSE_STREAM_OPERATION_OUTPUT, consumer=_consumer + ) return kwargs CONVERSE_STREAM = APIOperation( input=ConverseStreamInput, output=ConverseStreamOperationOutput, - static_schema=_SCHEMA_CONVERSE_STREAM, + schema=_SCHEMA_CONVERSE_STREAM, + input_schema=_SCHEMA_CONVERSE_STREAM_INPUT, + output_schema=_SCHEMA_CONVERSE_STREAM_OPERATION_OUTPUT, error_registry=TypeRegistry( { ShapeID( @@ -15346,6 +16590,17 @@ def _consumer(member_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, + ], ) @@ -15459,39 +16714,60 @@ class InvokeModelInput: """Key-value pairs that you can use to filter invocation logs.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_INVOKE_MODEL_INPUT), self) + serializer.write_struct(_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(members[0], self.body) + serializer.write_blob(_SCHEMA_INVOKE_MODEL_INPUT.members["body"], self.body) if self.content_type is not None: - serializer.write_string(members[1], self.content_type) + serializer.write_string( + _SCHEMA_INVOKE_MODEL_INPUT.members["contentType"], self.content_type + ) if self.accept is not None: - serializer.write_string(members[2], self.accept) + serializer.write_string( + _SCHEMA_INVOKE_MODEL_INPUT.members["accept"], self.accept + ) if self.model_id is not None: - serializer.write_string(members[3], self.model_id) + serializer.write_string( + _SCHEMA_INVOKE_MODEL_INPUT.members["modelId"], self.model_id + ) if self.trace is not None: - serializer.write_string(members[4], self.trace) + serializer.write_string( + _SCHEMA_INVOKE_MODEL_INPUT.members["trace"], self.trace + ) if self.guardrail_identifier is not None: - serializer.write_string(members[5], self.guardrail_identifier) + serializer.write_string( + _SCHEMA_INVOKE_MODEL_INPUT.members["guardrailIdentifier"], + self.guardrail_identifier, + ) if self.guardrail_version is not None: - serializer.write_string(members[6], self.guardrail_version) + serializer.write_string( + _SCHEMA_INVOKE_MODEL_INPUT.members["guardrailVersion"], + self.guardrail_version, + ) if self.performance_config_latency is not None: - serializer.write_string(members[7], self.performance_config_latency) + serializer.write_string( + _SCHEMA_INVOKE_MODEL_INPUT.members["performanceConfigLatency"], + self.performance_config_latency, + ) if self.service_tier is not None: - serializer.write_string(members[8], self.service_tier) + serializer.write_string( + _SCHEMA_INVOKE_MODEL_INPUT.members["serviceTier"], self.service_tier + ) if self.request_metadata is not None: - serializer.write_string(members[9], self.request_metadata) + serializer.write_string( + _SCHEMA_INVOKE_MODEL_INPUT.members["requestMetadata"], + self.request_metadata, + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -15500,47 +16776,69 @@ 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(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: - kwargs["body"] = de.read_blob(members[0]) + kwargs["body"] = de.read_blob( + _SCHEMA_INVOKE_MODEL_INPUT.members["body"] + ) case 1: - kwargs["content_type"] = de.read_string(members[1]) + kwargs["content_type"] = de.read_string( + _SCHEMA_INVOKE_MODEL_INPUT.members["contentType"] + ) case 2: - kwargs["accept"] = de.read_string(members[2]) + kwargs["accept"] = de.read_string( + _SCHEMA_INVOKE_MODEL_INPUT.members["accept"] + ) case 3: - kwargs["model_id"] = de.read_string(members[3]) + kwargs["model_id"] = de.read_string( + _SCHEMA_INVOKE_MODEL_INPUT.members["modelId"] + ) case 4: - kwargs["trace"] = Trace(de.read_string(members[4])) + kwargs["trace"] = Trace( + de.read_string(_SCHEMA_INVOKE_MODEL_INPUT.members["trace"]) + ) case 5: - kwargs["guardrail_identifier"] = de.read_string(members[5]) + kwargs["guardrail_identifier"] = de.read_string( + _SCHEMA_INVOKE_MODEL_INPUT.members["guardrailIdentifier"] + ) case 6: - kwargs["guardrail_version"] = de.read_string(members[6]) + kwargs["guardrail_version"] = de.read_string( + _SCHEMA_INVOKE_MODEL_INPUT.members["guardrailVersion"] + ) case 7: kwargs["performance_config_latency"] = PerformanceConfigLatency( - de.read_string(members[7]) + de.read_string( + _SCHEMA_INVOKE_MODEL_INPUT.members[ + "performanceConfigLatency" + ] + ) ) case 8: - kwargs["service_tier"] = ServiceTierType(de.read_string(members[8])) + kwargs["service_tier"] = ServiceTierType( + de.read_string( + _SCHEMA_INVOKE_MODEL_INPUT.members["serviceTier"] + ) + ) case 9: - kwargs["request_metadata"] = de.read_string(members[9]) + kwargs["request_metadata"] = de.read_string( + _SCHEMA_INVOKE_MODEL_INPUT.members["requestMetadata"] + ) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct(_SCHEMA_INVOKE_MODEL_INPUT, consumer=_consumer) return kwargs @@ -15576,17 +16874,23 @@ class InvokeModelOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_INVOKE_MODEL_OUTPUT), self) + serializer.write_struct(_SCHEMA_INVOKE_MODEL_OUTPUT, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_INVOKE_MODEL_OUTPUT).members_by_index - serializer.write_blob(members[0], self.body) - serializer.write_string(members[1], self.content_type) + serializer.write_blob(_SCHEMA_INVOKE_MODEL_OUTPUT.members["body"], self.body) + serializer.write_string( + _SCHEMA_INVOKE_MODEL_OUTPUT.members["contentType"], self.content_type + ) if self.performance_config_latency is not None: - serializer.write_string(members[2], self.performance_config_latency) + serializer.write_string( + _SCHEMA_INVOKE_MODEL_OUTPUT.members["performanceConfigLatency"], + self.performance_config_latency, + ) if self.service_tier is not None: - serializer.write_string(members[3], self.service_tier) + serializer.write_string( + _SCHEMA_INVOKE_MODEL_OUTPUT.members["serviceTier"], self.service_tier + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -15595,29 +16899,39 @@ 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(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: - kwargs["body"] = de.read_blob(members[0]) + kwargs["body"] = de.read_blob( + _SCHEMA_INVOKE_MODEL_OUTPUT.members["body"] + ) case 1: - kwargs["content_type"] = de.read_string(members[1]) + kwargs["content_type"] = de.read_string( + _SCHEMA_INVOKE_MODEL_OUTPUT.members["contentType"] + ) case 2: kwargs["performance_config_latency"] = PerformanceConfigLatency( - de.read_string(members[2]) + de.read_string( + _SCHEMA_INVOKE_MODEL_OUTPUT.members[ + "performanceConfigLatency" + ] + ) ) case 3: - kwargs["service_tier"] = ServiceTierType(de.read_string(members[3])) + kwargs["service_tier"] = ServiceTierType( + de.read_string( + _SCHEMA_INVOKE_MODEL_OUTPUT.members["serviceTier"] + ) + ) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct(_SCHEMA_INVOKE_MODEL_OUTPUT, consumer=_consumer) if "body" not in kwargs: kwargs["body"] = b"" if "content_type" not in kwargs: @@ -15628,7 +16942,9 @@ def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: INVOKE_MODEL = APIOperation( input=InvokeModelInput, output=InvokeModelOutput, - static_schema=_SCHEMA_INVOKE_MODEL, + schema=_SCHEMA_INVOKE_MODEL, + input_schema=_SCHEMA_INVOKE_MODEL_INPUT, + output_schema=_SCHEMA_INVOKE_MODEL_OUTPUT, error_registry=TypeRegistry( { ShapeID( @@ -15667,6 +16983,18 @@ def _consumer(member_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, + ], ) @@ -15681,12 +17009,13 @@ class BidirectionalInputPayloadPart: """The audio content for the bidirectional input.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_BIDIRECTIONAL_INPUT_PAYLOAD_PART), self) + serializer.write_struct(_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(members[0], self.bytes_) + serializer.write_blob( + _SCHEMA_BIDIRECTIONAL_INPUT_PAYLOAD_PART.members["bytes"], self.bytes_ + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -15695,18 +17024,20 @@ 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(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: - kwargs["bytes_"] = de.read_blob(members[0]) + kwargs["bytes_"] = de.read_blob( + _SCHEMA_BIDIRECTIONAL_INPUT_PAYLOAD_PART.members["bytes"] + ) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct( + _SCHEMA_BIDIRECTIONAL_INPUT_PAYLOAD_PART, consumer=_consumer + ) return kwargs @@ -15718,14 +17049,14 @@ class InvokeModelWithBidirectionalStreamInputChunk: def serialize(self, serializer: ShapeSerializer): serializer.write_struct( - hydrate(_SCHEMA_INVOKE_MODEL_WITH_BIDIRECTIONAL_STREAM_INPUT), self + _SCHEMA_INVOKE_MODEL_WITH_BIDIRECTIONAL_STREAM_INPUT, self ) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate( - _SCHEMA_INVOKE_MODEL_WITH_BIDIRECTIONAL_STREAM_INPUT - ).members_by_index - serializer.write_struct(members[0], self.value) + serializer.write_struct( + _SCHEMA_INVOKE_MODEL_WITH_BIDIRECTIONAL_STREAM_INPUT.members["chunk"], + self.value, + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -15774,8 +17105,7 @@ def deserialize( ) -> InvokeModelWithBidirectionalStreamInput: self._result = None deserializer.read_struct( - hydrate(_SCHEMA_INVOKE_MODEL_WITH_BIDIRECTIONAL_STREAM_INPUT), - self._consumer, + _SCHEMA_INVOKE_MODEL_WITH_BIDIRECTIONAL_STREAM_INPUT, self._consumer ) if self._result is None: @@ -15822,16 +17152,17 @@ class InvokeModelWithBidirectionalStreamOperationInput: def serialize(self, serializer: ShapeSerializer): serializer.write_struct( - hydrate(_SCHEMA_INVOKE_MODEL_WITH_BIDIRECTIONAL_STREAM_OPERATION_INPUT), - self, + _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(members[0], self.model_id) + serializer.write_string( + _SCHEMA_INVOKE_MODEL_WITH_BIDIRECTIONAL_STREAM_OPERATION_INPUT.members[ + "modelId" + ], + self.model_id, + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -15840,18 +17171,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_INPUT) - members = schema.members_by_index - def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: - kwargs["model_id"] = de.read_string(members[0]) + kwargs["model_id"] = de.read_string( + _SCHEMA_INVOKE_MODEL_WITH_BIDIRECTIONAL_STREAM_OPERATION_INPUT.members[ + "modelId" + ] + ) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct( + _SCHEMA_INVOKE_MODEL_WITH_BIDIRECTIONAL_STREAM_OPERATION_INPUT, + consumer=_consumer, + ) return kwargs @@ -15866,14 +17202,13 @@ class BidirectionalOutputPayloadPart: """The speech output of the bidirectional stream.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct( - hydrate(_SCHEMA_BIDIRECTIONAL_OUTPUT_PAYLOAD_PART), self - ) + serializer.write_struct(_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(members[0], self.bytes_) + serializer.write_blob( + _SCHEMA_BIDIRECTIONAL_OUTPUT_PAYLOAD_PART.members["bytes"], self.bytes_ + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -15882,18 +17217,20 @@ 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(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: - kwargs["bytes_"] = de.read_blob(members[0]) + kwargs["bytes_"] = de.read_blob( + _SCHEMA_BIDIRECTIONAL_OUTPUT_PAYLOAD_PART.members["bytes"] + ) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct( + _SCHEMA_BIDIRECTIONAL_OUTPUT_PAYLOAD_PART, consumer=_consumer + ) return kwargs @@ -15905,14 +17242,14 @@ class InvokeModelWithBidirectionalStreamOutputChunk: def serialize(self, serializer: ShapeSerializer): serializer.write_struct( - hydrate(_SCHEMA_INVOKE_MODEL_WITH_BIDIRECTIONAL_STREAM_OUTPUT), self + _SCHEMA_INVOKE_MODEL_WITH_BIDIRECTIONAL_STREAM_OUTPUT, self ) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate( - _SCHEMA_INVOKE_MODEL_WITH_BIDIRECTIONAL_STREAM_OUTPUT - ).members_by_index - serializer.write_struct(members[0], self.value) + serializer.write_struct( + _SCHEMA_INVOKE_MODEL_WITH_BIDIRECTIONAL_STREAM_OUTPUT.members["chunk"], + self.value, + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -15927,14 +17264,16 @@ class InvokeModelWithBidirectionalStreamOutputInternalServerException: def serialize(self, serializer: ShapeSerializer): serializer.write_struct( - hydrate(_SCHEMA_INVOKE_MODEL_WITH_BIDIRECTIONAL_STREAM_OUTPUT), self + _SCHEMA_INVOKE_MODEL_WITH_BIDIRECTIONAL_STREAM_OUTPUT, self ) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate( - _SCHEMA_INVOKE_MODEL_WITH_BIDIRECTIONAL_STREAM_OUTPUT - ).members_by_index - serializer.write_struct(members[1], self.value) + serializer.write_struct( + _SCHEMA_INVOKE_MODEL_WITH_BIDIRECTIONAL_STREAM_OUTPUT.members[ + "internalServerException" + ], + self.value, + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -15949,14 +17288,16 @@ class InvokeModelWithBidirectionalStreamOutputModelStreamErrorException: def serialize(self, serializer: ShapeSerializer): serializer.write_struct( - hydrate(_SCHEMA_INVOKE_MODEL_WITH_BIDIRECTIONAL_STREAM_OUTPUT), self + _SCHEMA_INVOKE_MODEL_WITH_BIDIRECTIONAL_STREAM_OUTPUT, self ) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate( - _SCHEMA_INVOKE_MODEL_WITH_BIDIRECTIONAL_STREAM_OUTPUT - ).members_by_index - serializer.write_struct(members[2], self.value) + serializer.write_struct( + _SCHEMA_INVOKE_MODEL_WITH_BIDIRECTIONAL_STREAM_OUTPUT.members[ + "modelStreamErrorException" + ], + self.value, + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -15974,14 +17315,16 @@ class InvokeModelWithBidirectionalStreamOutputValidationException: def serialize(self, serializer: ShapeSerializer): serializer.write_struct( - hydrate(_SCHEMA_INVOKE_MODEL_WITH_BIDIRECTIONAL_STREAM_OUTPUT), self + _SCHEMA_INVOKE_MODEL_WITH_BIDIRECTIONAL_STREAM_OUTPUT, self ) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate( - _SCHEMA_INVOKE_MODEL_WITH_BIDIRECTIONAL_STREAM_OUTPUT - ).members_by_index - serializer.write_struct(members[3], self.value) + serializer.write_struct( + _SCHEMA_INVOKE_MODEL_WITH_BIDIRECTIONAL_STREAM_OUTPUT.members[ + "validationException" + ], + self.value, + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -15996,14 +17339,16 @@ class InvokeModelWithBidirectionalStreamOutputThrottlingException: def serialize(self, serializer: ShapeSerializer): serializer.write_struct( - hydrate(_SCHEMA_INVOKE_MODEL_WITH_BIDIRECTIONAL_STREAM_OUTPUT), self + _SCHEMA_INVOKE_MODEL_WITH_BIDIRECTIONAL_STREAM_OUTPUT, self ) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate( - _SCHEMA_INVOKE_MODEL_WITH_BIDIRECTIONAL_STREAM_OUTPUT - ).members_by_index - serializer.write_struct(members[4], self.value) + serializer.write_struct( + _SCHEMA_INVOKE_MODEL_WITH_BIDIRECTIONAL_STREAM_OUTPUT.members[ + "throttlingException" + ], + self.value, + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -16021,14 +17366,16 @@ class InvokeModelWithBidirectionalStreamOutputModelTimeoutException: def serialize(self, serializer: ShapeSerializer): serializer.write_struct( - hydrate(_SCHEMA_INVOKE_MODEL_WITH_BIDIRECTIONAL_STREAM_OUTPUT), self + _SCHEMA_INVOKE_MODEL_WITH_BIDIRECTIONAL_STREAM_OUTPUT, self ) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate( - _SCHEMA_INVOKE_MODEL_WITH_BIDIRECTIONAL_STREAM_OUTPUT - ).members_by_index - serializer.write_struct(members[5], self.value) + serializer.write_struct( + _SCHEMA_INVOKE_MODEL_WITH_BIDIRECTIONAL_STREAM_OUTPUT.members[ + "modelTimeoutException" + ], + self.value, + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -16043,14 +17390,16 @@ class InvokeModelWithBidirectionalStreamOutputServiceUnavailableException: def serialize(self, serializer: ShapeSerializer): serializer.write_struct( - hydrate(_SCHEMA_INVOKE_MODEL_WITH_BIDIRECTIONAL_STREAM_OUTPUT), self + _SCHEMA_INVOKE_MODEL_WITH_BIDIRECTIONAL_STREAM_OUTPUT, self ) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate( - _SCHEMA_INVOKE_MODEL_WITH_BIDIRECTIONAL_STREAM_OUTPUT - ).members_by_index - serializer.write_struct(members[6], self.value) + serializer.write_struct( + _SCHEMA_INVOKE_MODEL_WITH_BIDIRECTIONAL_STREAM_OUTPUT.members[ + "serviceUnavailableException" + ], + self.value, + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -16102,8 +17451,7 @@ def deserialize( ) -> InvokeModelWithBidirectionalStreamOutput: self._result = None deserializer.read_struct( - hydrate(_SCHEMA_INVOKE_MODEL_WITH_BIDIRECTIONAL_STREAM_OUTPUT), - self._consumer, + _SCHEMA_INVOKE_MODEL_WITH_BIDIRECTIONAL_STREAM_OUTPUT, self._consumer ) if self._result is None: @@ -16196,8 +17544,7 @@ class InvokeModelWithBidirectionalStreamOperationOutput: def serialize(self, serializer: ShapeSerializer): serializer.write_struct( - hydrate(_SCHEMA_INVOKE_MODEL_WITH_BIDIRECTIONAL_STREAM_OPERATION_OUTPUT), - self, + _SCHEMA_INVOKE_MODEL_WITH_BIDIRECTIONAL_STREAM_OPERATION_OUTPUT, self ) def serialize_members(self, serializer: ShapeSerializer): @@ -16210,23 +17557,25 @@ 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(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct( + _SCHEMA_INVOKE_MODEL_WITH_BIDIRECTIONAL_STREAM_OPERATION_OUTPUT, + consumer=_consumer, + ) return kwargs INVOKE_MODEL_WITH_BIDIRECTIONAL_STREAM = APIOperation( input=InvokeModelWithBidirectionalStreamOperationInput, output=InvokeModelWithBidirectionalStreamOperationOutput, - static_schema=_SCHEMA_INVOKE_MODEL_WITH_BIDIRECTIONAL_STREAM, + 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, error_registry=TypeRegistry( { ShapeID( @@ -16268,6 +17617,19 @@ def _consumer(member_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, + ], ) @@ -16375,43 +17737,76 @@ class InvokeModelWithResponseStreamInput: """Key-value pairs that you can use to filter invocation logs.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct( - hydrate(_SCHEMA_INVOKE_MODEL_WITH_RESPONSE_STREAM_INPUT), self - ) + serializer.write_struct(_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(members[0], self.body) + serializer.write_blob( + _SCHEMA_INVOKE_MODEL_WITH_RESPONSE_STREAM_INPUT.members["body"], + self.body, + ) if self.content_type is not None: - serializer.write_string(members[1], self.content_type) + serializer.write_string( + _SCHEMA_INVOKE_MODEL_WITH_RESPONSE_STREAM_INPUT.members["contentType"], + self.content_type, + ) if self.accept is not None: - serializer.write_string(members[2], self.accept) + serializer.write_string( + _SCHEMA_INVOKE_MODEL_WITH_RESPONSE_STREAM_INPUT.members["accept"], + self.accept, + ) if self.model_id is not None: - serializer.write_string(members[3], self.model_id) + serializer.write_string( + _SCHEMA_INVOKE_MODEL_WITH_RESPONSE_STREAM_INPUT.members["modelId"], + self.model_id, + ) if self.trace is not None: - serializer.write_string(members[4], self.trace) + serializer.write_string( + _SCHEMA_INVOKE_MODEL_WITH_RESPONSE_STREAM_INPUT.members["trace"], + self.trace, + ) if self.guardrail_identifier is not None: - serializer.write_string(members[5], self.guardrail_identifier) + serializer.write_string( + _SCHEMA_INVOKE_MODEL_WITH_RESPONSE_STREAM_INPUT.members[ + "guardrailIdentifier" + ], + self.guardrail_identifier, + ) if self.guardrail_version is not None: - serializer.write_string(members[6], self.guardrail_version) + serializer.write_string( + _SCHEMA_INVOKE_MODEL_WITH_RESPONSE_STREAM_INPUT.members[ + "guardrailVersion" + ], + self.guardrail_version, + ) if self.performance_config_latency is not None: - serializer.write_string(members[7], self.performance_config_latency) + serializer.write_string( + _SCHEMA_INVOKE_MODEL_WITH_RESPONSE_STREAM_INPUT.members[ + "performanceConfigLatency" + ], + self.performance_config_latency, + ) if self.service_tier is not None: - serializer.write_string(members[8], self.service_tier) + serializer.write_string( + _SCHEMA_INVOKE_MODEL_WITH_RESPONSE_STREAM_INPUT.members["serviceTier"], + self.service_tier, + ) if self.request_metadata is not None: - serializer.write_string(members[9], self.request_metadata) + serializer.write_string( + _SCHEMA_INVOKE_MODEL_WITH_RESPONSE_STREAM_INPUT.members[ + "requestMetadata" + ], + self.request_metadata, + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -16420,47 +17815,89 @@ 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(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: - kwargs["body"] = de.read_blob(members[0]) + kwargs["body"] = de.read_blob( + _SCHEMA_INVOKE_MODEL_WITH_RESPONSE_STREAM_INPUT.members["body"] + ) case 1: - kwargs["content_type"] = de.read_string(members[1]) + kwargs["content_type"] = de.read_string( + _SCHEMA_INVOKE_MODEL_WITH_RESPONSE_STREAM_INPUT.members[ + "contentType" + ] + ) case 2: - kwargs["accept"] = de.read_string(members[2]) + kwargs["accept"] = de.read_string( + _SCHEMA_INVOKE_MODEL_WITH_RESPONSE_STREAM_INPUT.members[ + "accept" + ] + ) case 3: - kwargs["model_id"] = de.read_string(members[3]) + kwargs["model_id"] = de.read_string( + _SCHEMA_INVOKE_MODEL_WITH_RESPONSE_STREAM_INPUT.members[ + "modelId" + ] + ) case 4: - kwargs["trace"] = Trace(de.read_string(members[4])) + kwargs["trace"] = Trace( + de.read_string( + _SCHEMA_INVOKE_MODEL_WITH_RESPONSE_STREAM_INPUT.members[ + "trace" + ] + ) + ) case 5: - kwargs["guardrail_identifier"] = de.read_string(members[5]) + kwargs["guardrail_identifier"] = de.read_string( + _SCHEMA_INVOKE_MODEL_WITH_RESPONSE_STREAM_INPUT.members[ + "guardrailIdentifier" + ] + ) case 6: - kwargs["guardrail_version"] = de.read_string(members[6]) + kwargs["guardrail_version"] = de.read_string( + _SCHEMA_INVOKE_MODEL_WITH_RESPONSE_STREAM_INPUT.members[ + "guardrailVersion" + ] + ) case 7: kwargs["performance_config_latency"] = PerformanceConfigLatency( - de.read_string(members[7]) + de.read_string( + _SCHEMA_INVOKE_MODEL_WITH_RESPONSE_STREAM_INPUT.members[ + "performanceConfigLatency" + ] + ) ) case 8: - kwargs["service_tier"] = ServiceTierType(de.read_string(members[8])) + kwargs["service_tier"] = ServiceTierType( + de.read_string( + _SCHEMA_INVOKE_MODEL_WITH_RESPONSE_STREAM_INPUT.members[ + "serviceTier" + ] + ) + ) case 9: - kwargs["request_metadata"] = de.read_string(members[9]) + kwargs["request_metadata"] = de.read_string( + _SCHEMA_INVOKE_MODEL_WITH_RESPONSE_STREAM_INPUT.members[ + "requestMetadata" + ] + ) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct( + _SCHEMA_INVOKE_MODEL_WITH_RESPONSE_STREAM_INPUT, consumer=_consumer + ) return kwargs @@ -16472,12 +17909,11 @@ class PayloadPart: """Base64-encoded bytes of payload data.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_PAYLOAD_PART), self) + serializer.write_struct(_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(members[0], self.bytes_) + serializer.write_blob(_SCHEMA_PAYLOAD_PART.members["bytes"], self.bytes_) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -16486,18 +17922,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(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: - kwargs["bytes_"] = de.read_blob(members[0]) + kwargs["bytes_"] = de.read_blob( + _SCHEMA_PAYLOAD_PART.members["bytes"] + ) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct(_SCHEMA_PAYLOAD_PART, consumer=_consumer) return kwargs @@ -16508,11 +17944,10 @@ class ResponseStreamChunk: value: PayloadPart def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_RESPONSE_STREAM), self) + serializer.write_struct(_SCHEMA_RESPONSE_STREAM, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_RESPONSE_STREAM).members_by_index - serializer.write_struct(members[0], self.value) + serializer.write_struct(_SCHEMA_RESPONSE_STREAM.members["chunk"], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -16526,11 +17961,12 @@ class ResponseStreamInternalServerException: value: InternalServerException def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_RESPONSE_STREAM), self) + serializer.write_struct(_SCHEMA_RESPONSE_STREAM, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_RESPONSE_STREAM).members_by_index - serializer.write_struct(members[1], self.value) + serializer.write_struct( + _SCHEMA_RESPONSE_STREAM.members["internalServerException"], self.value + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -16544,11 +17980,12 @@ class ResponseStreamModelStreamErrorException: value: ModelStreamErrorException def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_RESPONSE_STREAM), self) + serializer.write_struct(_SCHEMA_RESPONSE_STREAM, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_RESPONSE_STREAM).members_by_index - serializer.write_struct(members[2], self.value) + serializer.write_struct( + _SCHEMA_RESPONSE_STREAM.members["modelStreamErrorException"], self.value + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -16565,11 +18002,12 @@ class ResponseStreamValidationException: value: ValidationException def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_RESPONSE_STREAM), self) + serializer.write_struct(_SCHEMA_RESPONSE_STREAM, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_RESPONSE_STREAM).members_by_index - serializer.write_struct(members[3], self.value) + serializer.write_struct( + _SCHEMA_RESPONSE_STREAM.members["validationException"], self.value + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -16589,11 +18027,12 @@ class ResponseStreamThrottlingException: value: ThrottlingException def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_RESPONSE_STREAM), self) + serializer.write_struct(_SCHEMA_RESPONSE_STREAM, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_RESPONSE_STREAM).members_by_index - serializer.write_struct(members[4], self.value) + serializer.write_struct( + _SCHEMA_RESPONSE_STREAM.members["throttlingException"], self.value + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -16610,11 +18049,12 @@ class ResponseStreamModelTimeoutException: value: ModelTimeoutException def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_RESPONSE_STREAM), self) + serializer.write_struct(_SCHEMA_RESPONSE_STREAM, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_RESPONSE_STREAM).members_by_index - serializer.write_struct(members[5], self.value) + serializer.write_struct( + _SCHEMA_RESPONSE_STREAM.members["modelTimeoutException"], self.value + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -16628,11 +18068,12 @@ class ResponseStreamServiceUnavailableException: value: ServiceUnavailableException def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_RESPONSE_STREAM), self) + serializer.write_struct(_SCHEMA_RESPONSE_STREAM, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_RESPONSE_STREAM).members_by_index - serializer.write_struct(members[6], self.value) + serializer.write_struct( + _SCHEMA_RESPONSE_STREAM.members["serviceUnavailableException"], self.value + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -16681,7 +18122,7 @@ class _ResponseStreamDeserializer: def deserialize(self, deserializer: ShapeDeserializer) -> ResponseStream: self._result = None - deserializer.read_struct(hydrate(_SCHEMA_RESPONSE_STREAM), self._consumer) + deserializer.read_struct(_SCHEMA_RESPONSE_STREAM, self._consumer) if self._result is None: raise SerializationError( @@ -16752,20 +18193,26 @@ class InvokeModelWithResponseStreamOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct( - hydrate(_SCHEMA_INVOKE_MODEL_WITH_RESPONSE_STREAM_OUTPUT), self - ) + serializer.write_struct(_SCHEMA_INVOKE_MODEL_WITH_RESPONSE_STREAM_OUTPUT, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate( - _SCHEMA_INVOKE_MODEL_WITH_RESPONSE_STREAM_OUTPUT - ).members_by_index - serializer.write_string(members[1], self.content_type) + serializer.write_string( + _SCHEMA_INVOKE_MODEL_WITH_RESPONSE_STREAM_OUTPUT.members["contentType"], + self.content_type, + ) if self.performance_config_latency is not None: - serializer.write_string(members[2], self.performance_config_latency) + serializer.write_string( + _SCHEMA_INVOKE_MODEL_WITH_RESPONSE_STREAM_OUTPUT.members[ + "performanceConfigLatency" + ], + self.performance_config_latency, + ) if self.service_tier is not None: - serializer.write_string(members[3], self.service_tier) + serializer.write_string( + _SCHEMA_INVOKE_MODEL_WITH_RESPONSE_STREAM_OUTPUT.members["serviceTier"], + self.service_tier, + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -16774,26 +18221,40 @@ 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(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 1: - kwargs["content_type"] = de.read_string(members[1]) + kwargs["content_type"] = de.read_string( + _SCHEMA_INVOKE_MODEL_WITH_RESPONSE_STREAM_OUTPUT.members[ + "contentType" + ] + ) case 2: kwargs["performance_config_latency"] = PerformanceConfigLatency( - de.read_string(members[2]) + de.read_string( + _SCHEMA_INVOKE_MODEL_WITH_RESPONSE_STREAM_OUTPUT.members[ + "performanceConfigLatency" + ] + ) ) case 3: - kwargs["service_tier"] = ServiceTierType(de.read_string(members[3])) + kwargs["service_tier"] = ServiceTierType( + de.read_string( + _SCHEMA_INVOKE_MODEL_WITH_RESPONSE_STREAM_OUTPUT.members[ + "serviceTier" + ] + ) + ) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct( + _SCHEMA_INVOKE_MODEL_WITH_RESPONSE_STREAM_OUTPUT, consumer=_consumer + ) if "content_type" not in kwargs: kwargs["content_type"] = "" return kwargs @@ -16802,7 +18263,9 @@ def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: INVOKE_MODEL_WITH_RESPONSE_STREAM = APIOperation( input=InvokeModelWithResponseStreamInput, output=InvokeModelWithResponseStreamOutput, - static_schema=_SCHEMA_INVOKE_MODEL_WITH_RESPONSE_STREAM, + 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, error_registry=TypeRegistry( { ShapeID( @@ -16844,6 +18307,19 @@ def _consumer(member_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, + ], ) @@ -16881,21 +18357,33 @@ class ConverseTokensRequest: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_CONVERSE_TOKENS_REQUEST), self) + serializer.write_struct(_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, members[0], self.messages) + _serialize_messages( + serializer, + _SCHEMA_CONVERSE_TOKENS_REQUEST.members["messages"], + self.messages, + ) if self.system is not None: - _serialize_system_content_blocks(serializer, members[1], self.system) + _serialize_system_content_blocks( + serializer, + _SCHEMA_CONVERSE_TOKENS_REQUEST.members["system"], + self.system, + ) if self.tool_config is not None: - serializer.write_struct(members[2], self.tool_config) + serializer.write_struct( + _SCHEMA_CONVERSE_TOKENS_REQUEST.members["toolConfig"], self.tool_config + ) if self.additional_model_request_fields is not None: - serializer.write_document(members[3], self.additional_model_request_fields) + serializer.write_document( + _SCHEMA_CONVERSE_TOKENS_REQUEST.members["additionalModelRequestFields"], + self.additional_model_request_fields, + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -16904,17 +18392,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(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: - kwargs["messages"] = _deserialize_messages(de, members[0]) + kwargs["messages"] = _deserialize_messages( + de, _SCHEMA_CONVERSE_TOKENS_REQUEST.members["messages"] + ) case 1: kwargs["system"] = _deserialize_system_content_blocks( - de, members[1] + de, _SCHEMA_CONVERSE_TOKENS_REQUEST.members["system"] ) case 2: @@ -16922,13 +18410,15 @@ def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: case 3: kwargs["additional_model_request_fields"] = de.read_document( - members[3] + _SCHEMA_CONVERSE_TOKENS_REQUEST.members[ + "additionalModelRequestFields" + ] ) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct(_SCHEMA_CONVERSE_TOKENS_REQUEST, consumer=_consumer) return kwargs @@ -16949,11 +18439,12 @@ class InvokeModelTokensRequest: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_INVOKE_MODEL_TOKENS_REQUEST), self) + serializer.write_struct(_SCHEMA_INVOKE_MODEL_TOKENS_REQUEST, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_INVOKE_MODEL_TOKENS_REQUEST).members_by_index - serializer.write_blob(members[0], self.body) + serializer.write_blob( + _SCHEMA_INVOKE_MODEL_TOKENS_REQUEST.members["body"], self.body + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -16962,18 +18453,20 @@ 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(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: - kwargs["body"] = de.read_blob(members[0]) + kwargs["body"] = de.read_blob( + _SCHEMA_INVOKE_MODEL_TOKENS_REQUEST.members["body"] + ) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct( + _SCHEMA_INVOKE_MODEL_TOKENS_REQUEST, consumer=_consumer + ) if "body" not in kwargs: kwargs["body"] = b"" return kwargs @@ -16990,11 +18483,12 @@ class CountTokensInputInvokeModel: value: InvokeModelTokensRequest def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_COUNT_TOKENS_INPUT), self) + serializer.write_struct(_SCHEMA_COUNT_TOKENS_INPUT, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_COUNT_TOKENS_INPUT).members_by_index - serializer.write_struct(members[0], self.value) + serializer.write_struct( + _SCHEMA_COUNT_TOKENS_INPUT.members["invokeModel"], self.value + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -17012,11 +18506,12 @@ class CountTokensInputConverse: value: ConverseTokensRequest def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_COUNT_TOKENS_INPUT), self) + serializer.write_struct(_SCHEMA_COUNT_TOKENS_INPUT, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_COUNT_TOKENS_INPUT).members_by_index - serializer.write_struct(members[1], self.value) + serializer.write_struct( + _SCHEMA_COUNT_TOKENS_INPUT.members["converse"], self.value + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -17061,7 +18556,7 @@ class _CountTokensInputDeserializer: def deserialize(self, deserializer: ShapeDeserializer) -> CountTokensInput: self._result = None - deserializer.read_struct(hydrate(_SCHEMA_COUNT_TOKENS_INPUT), self._consumer) + deserializer.read_struct(_SCHEMA_COUNT_TOKENS_INPUT, self._consumer) if self._result is None: raise SerializationError( @@ -17119,15 +18614,18 @@ class CountTokensOperationInput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_COUNT_TOKENS_OPERATION_INPUT), self) + serializer.write_struct(_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(members[0], self.model_id) + serializer.write_string( + _SCHEMA_COUNT_TOKENS_OPERATION_INPUT.members["modelId"], self.model_id + ) if self.input is not None: - serializer.write_struct(members[1], self.input) + serializer.write_struct( + _SCHEMA_COUNT_TOKENS_OPERATION_INPUT.members["input"], self.input + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -17136,21 +18634,23 @@ 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(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: - kwargs["model_id"] = de.read_string(members[0]) + kwargs["model_id"] = de.read_string( + _SCHEMA_COUNT_TOKENS_OPERATION_INPUT.members["modelId"] + ) case 1: kwargs["input"] = _CountTokensInputDeserializer().deserialize(de) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct( + _SCHEMA_COUNT_TOKENS_OPERATION_INPUT, consumer=_consumer + ) return kwargs @@ -17178,11 +18678,12 @@ class CountTokensOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(hydrate(_SCHEMA_COUNT_TOKENS_OUTPUT), self) + serializer.write_struct(_SCHEMA_COUNT_TOKENS_OUTPUT, self) def serialize_members(self, serializer: ShapeSerializer): - members = hydrate(_SCHEMA_COUNT_TOKENS_OUTPUT).members_by_index - serializer.write_integer(members[0], self.input_tokens) + serializer.write_integer( + _SCHEMA_COUNT_TOKENS_OUTPUT.members["inputTokens"], self.input_tokens + ) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -17191,18 +18692,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(member_schema: Schema, de: ShapeDeserializer) -> None: - match member_schema.expect_member_index(): + def _consumer(schema: Schema, de: ShapeDeserializer) -> None: + match schema.expect_member_index(): case 0: - kwargs["input_tokens"] = de.read_integer(members[0]) + kwargs["input_tokens"] = de.read_integer( + _SCHEMA_COUNT_TOKENS_OUTPUT.members["inputTokens"] + ) case _: - logger.debug("Unexpected member schema: %s", member_schema) + logger.debug("Unexpected member schema: %s", schema) - deserializer.read_struct(schema, consumer=_consumer) + deserializer.read_struct(_SCHEMA_COUNT_TOKENS_OUTPUT, consumer=_consumer) if "input_tokens" not in kwargs: kwargs["input_tokens"] = 0 return kwargs @@ -17211,7 +18712,9 @@ def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: COUNT_TOKENS = APIOperation( input=CountTokensOperationInput, output=CountTokensOutput, - static_schema=_SCHEMA_COUNT_TOKENS, + schema=_SCHEMA_COUNT_TOKENS, + input_schema=_SCHEMA_COUNT_TOKENS_OPERATION_INPUT, + output_schema=_SCHEMA_COUNT_TOKENS_OUTPUT, error_registry=TypeRegistry( { ShapeID( @@ -17238,4 +18741,12 @@ def _consumer(member_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, + ], )